; generated by Component: ARM Compiler 5.05 (build 41) Tool: ArmCC [4d0eb9]
; commandline ArmCC [--thumb --list --debug -c --asm --interleave -o.\obj\isp_iap.o --asm_dir=.\Obj\ --list_dir=.\Obj\ --depend=.\obj\isp_iap.d --apcs=interwork -O0 -IC:\Keil\ARM\RV31\INC -IC:\Keil\ARM\CMSIS\Include -IC:\Keil\ARM\Inc\Philips --omf_browse=.\obj\isp_iap.crf isp\isp_iap.c]
                          THUMB

                          AREA ||.text||, CODE, READONLY, ALIGN=2

                  is_div PROC
;;;34     
;;;35     int is_div(unsigned value,unsigned div)
000000  0002              MOVS     r2,r0
;;;36     {
;;;37         if(value & (div -1))
000002  1e48              SUBS     r0,r1,#1
000004  4010              ANDS     r0,r0,r2
000006  2800              CMP      r0,#0
000008  d001              BEQ      |L1.14|
;;;38         {
;;;39             return(1);
00000a  2001              MOVS     r0,#1
                  |L1.12|
;;;40         }
;;;41         else
;;;42         {
;;;43             return(0);
;;;44         }
;;;45     }/* is_div */
00000c  4770              BX       lr
                  |L1.14|
00000e  2000              MOVS     r0,#0                 ;43
000010  e7fc              B        |L1.12|
;;;46     
                          ENDP

                  __rt_div0 PROC
;;;47     void __rt_div0(void)
000012  4770              BX       lr
;;;48     {
;;;49     } /* __rt_div0 */
;;;50     
                          ENDP

                  str_cmp PROC
;;;51     int str_cmp(char * src, char * dst)
000014  b410              PUSH     {r4}
;;;52     {
000016  0002              MOVS     r2,r0
000018  000b              MOVS     r3,r1
;;;53         int i = 0;
00001a  2100              MOVS     r1,#0
;;;54         
;;;55         for(i=0;src[i] == dst[i];i++)
00001c  46c0              MOV      r8,r8
00001e  e005              B        |L1.44|
                  |L1.32|
;;;56         {
;;;57             if(src[i] == NUL)
000020  5c50              LDRB     r0,[r2,r1]
000022  2800              CMP      r0,#0
000024  d101              BNE      |L1.42|
                  |L1.38|
;;;58             {
;;;59                 return(NUL);
;;;60             }
;;;61         }
;;;62         return(src[i]-dst[i]);
;;;63     } /* str_cmp */
000026  bc10              POP      {r4}
000028  4770              BX       lr
                  |L1.42|
00002a  1c49              ADDS     r1,r1,#1              ;55
                  |L1.44|
00002c  5c50              LDRB     r0,[r2,r1]            ;55
00002e  5c5c              LDRB     r4,[r3,r1]            ;55
000030  42a0              CMP      r0,r4                 ;55
000032  d0f5              BEQ      |L1.32|
000034  5c50              LDRB     r0,[r2,r1]            ;62
000036  5c5c              LDRB     r4,[r3,r1]            ;62
000038  1b00              SUBS     r0,r0,r4              ;62
00003a  e7f4              B        |L1.38|
;;;64     
                          ENDP

                  a_to_i PROC
;;;65     int a_to_i(char * inbuf,unsigned * outint)
00003c  b430              PUSH     {r4,r5}
;;;66     {
00003e  0002              MOVS     r2,r0
000040  000b              MOVS     r3,r1
;;;67         unsigned int value=0,i;
000042  2400              MOVS     r4,#0
;;;68         
;;;69         for(i=0;inbuf[i] != 0;i++)
000044  2100              MOVS     r1,#0
000046  e00f              B        |L1.104|
                  |L1.72|
;;;70         {
;;;71             if(inbuf[i] >= '0' && inbuf[i] <= '9')
000048  5c50              LDRB     r0,[r2,r1]
00004a  2830              CMP      r0,#0x30
00004c  db08              BLT      |L1.96|
00004e  5c50              LDRB     r0,[r2,r1]
000050  2839              CMP      r0,#0x39
000052  dc05              BGT      |L1.96|
;;;72             {
;;;73                 value = 10 * value +(inbuf[i] - '0');
000054  200a              MOVS     r0,#0xa
000056  4360              MULS     r0,r4,r0
000058  5c55              LDRB     r5,[r2,r1]
00005a  3d30              SUBS     r5,r5,#0x30
00005c  1944              ADDS     r4,r0,r5
00005e  e002              B        |L1.102|
                  |L1.96|
;;;74             }
;;;75             else
;;;76             {
;;;77                 return(1);
000060  2001              MOVS     r0,#1
                  |L1.98|
;;;78             }
;;;79         }
;;;80         *outint = value;
;;;81         return(0);
;;;82     } /* a_to_i */
000062  bc30              POP      {r4,r5}
000064  4770              BX       lr
                  |L1.102|
000066  1c49              ADDS     r1,r1,#1              ;69
                  |L1.104|
000068  5c50              LDRB     r0,[r2,r1]            ;69
00006a  2800              CMP      r0,#0                 ;69
00006c  d1ec              BNE      |L1.72|
00006e  601c              STR      r4,[r3,#0]            ;80
000070  46c0              MOV      r8,r8                 ;81
000072  e7f6              B        |L1.98|
;;;83     
                          ENDP

                  i_to_a PROC
;;;84     
;;;85     char * i_to_a(unsigned i_num, char * str, unsigned str_len)
000074  b5f8              PUSH     {r3-r7,lr}
;;;86     {
000076  0007              MOVS     r7,r0
000078  000d              MOVS     r5,r1
00007a  0014              MOVS     r4,r2
;;;87         char remainder;
;;;88     
;;;89         str[--str_len] = NUL;
00007c  2100              MOVS     r1,#0
00007e  1e60              SUBS     r0,r4,#1
000080  0004              MOVS     r4,r0
000082  5429              STRB     r1,[r5,r0]
;;;90     
;;;91         if(i_num == 0)
000084  2f00              CMP      r7,#0
000086  d107              BNE      |L1.152|
;;;92         {
;;;93             str[--str_len] = '0';
000088  2130              MOVS     r1,#0x30
00008a  1e60              SUBS     r0,r4,#1
00008c  0004              MOVS     r4,r0
00008e  5429              STRB     r1,[r5,r0]
;;;94             return(str + str_len);
000090  1928              ADDS     r0,r5,r4
                  |L1.146|
;;;95         }
;;;96     
;;;97         while (((str_len>0) && (i_num!=0)))
;;;98         {
;;;99             str_len--;
;;;100            remainder = (char) (i_num % 10);
;;;101            if ( remainder <= 9 )
;;;102            {
;;;103                str[str_len] = remainder + '0';
;;;104            }
;;;105            else  
;;;106            {
;;;107                str[str_len] = remainder - 10 + 'A';
;;;108            }
;;;109            i_num = i_num/10;
;;;110        }
;;;111        return (str + str_len);
;;;112    } /* i_to_a */
000092  bcf8              POP      {r3-r7}
000094  bc08              POP      {r3}
000096  4718              BX       r3
                  |L1.152|
000098  e013              B        |L1.194|
                  |L1.154|
00009a  1e64              SUBS     r4,r4,#1              ;99
00009c  210a              MOVS     r1,#0xa               ;100
00009e  0038              MOVS     r0,r7                 ;100
0000a0  f7fffffe          BL       __aeabi_uidivmod
0000a4  000e              MOVS     r6,r1                 ;100
0000a6  2e09              CMP      r6,#9                 ;101
0000a8  dc03              BGT      |L1.178|
0000aa  0030              MOVS     r0,r6                 ;103
0000ac  3030              ADDS     r0,r0,#0x30           ;103
0000ae  5528              STRB     r0,[r5,r4]            ;103
0000b0  e002              B        |L1.184|
                  |L1.178|
0000b2  0030              MOVS     r0,r6                 ;107
0000b4  3037              ADDS     r0,r0,#0x37           ;107
0000b6  5528              STRB     r0,[r5,r4]            ;107
                  |L1.184|
0000b8  210a              MOVS     r1,#0xa               ;109
0000ba  0038              MOVS     r0,r7                 ;109
0000bc  f7fffffe          BL       __aeabi_uidivmod
0000c0  0007              MOVS     r7,r0                 ;109
                  |L1.194|
0000c2  2c00              CMP      r4,#0                 ;97
0000c4  d001              BEQ      |L1.202|
0000c6  2f00              CMP      r7,#0                 ;97
0000c8  d1e7              BNE      |L1.154|
                  |L1.202|
0000ca  1928              ADDS     r0,r5,r4              ;111
0000cc  e7e1              B        |L1.146|
;;;113    
                          ENDP

                  run_isp PROC
;;;114    const char sync_str[] = "Synchronized";
;;;115    void run_isp(void)
0000ce  b508              PUSH     {r3,lr}
;;;116    {
;;;117        int count;
;;;118    
;;;119        /* wait for host to initiate communication */
;;;120    	getline(cmd_buf,CMD_SIZE,&count);
0000d0  466a              MOV      r2,sp
0000d2  2146              MOVS     r1,#0x46
0000d4  48f8              LDR      r0,|L1.1208|
0000d6  f7fffffe          BL       getline
;;;121    
;;;122    	/* send "Synchronized" string response */
;;;123    	sendline_crlf((char *)sync_str);
0000da  48f8              LDR      r0,|L1.1212|
0000dc  f7fffffe          BL       sendline_crlf
;;;124    
;;;125        /* wait for host to respond */
;;;126    	getline(cmd_buf,CMD_SIZE,&count);
0000e0  466a              MOV      r2,sp
0000e2  2146              MOVS     r1,#0x46
0000e4  48f4              LDR      r0,|L1.1208|
0000e6  f7fffffe          BL       getline
;;;127    
;;;128    	/* Compare HOST response with the original string */
;;;129    	if(str_cmp(cmd_buf,(char *)sync_str) == 0)
0000ea  49f4              LDR      r1,|L1.1212|
0000ec  48f2              LDR      r0,|L1.1208|
0000ee  f7fffffe          BL       str_cmp
;;;130    	{
;;;131    		/* Autobaud is successful. Get out of while loop. */
;;;132    	}
;;;133    	else
;;;134    	{
;;;135    	}
;;;136    }
0000f2  b001              ADD      sp,sp,#4
0000f4  bc08              POP      {r3}
0000f6  4718              BX       r3
;;;137    
                          ENDP

                  param_check PROC
;;;138    unsigned param_check(char * param_str,unsigned * param_ptr,int param_type,int count)
0000f8  b5ff              PUSH     {r0-r7,lr}
;;;139    {
0000fa  b082              SUB      sp,sp,#8
0000fc  000d              MOVS     r5,r1
0000fe  0014              MOVS     r4,r2
;;;140        int rc,return_code,in_flash,in_ram;
;;;141        return_code = 0;
000100  2000              MOVS     r0,#0
000102  9001              STR      r0,[sp,#4]
;;;142        /* check if conversion from str to integer is required */
;;;143        if(param_str != NUL)
000104  9802              LDR      r0,[sp,#8]
000106  2800              CMP      r0,#0
000108  d00b              BEQ      |L1.290|
;;;144        {
;;;145            rc = a_to_i(param_str,param_ptr);
00010a  0029              MOVS     r1,r5
00010c  9802              LDR      r0,[sp,#8]
00010e  f7fffffe          BL       a_to_i
000112  0006              MOVS     r6,r0
;;;146            if(rc != 0)
000114  2e00              CMP      r6,#0
000116  d004              BEQ      |L1.290|
;;;147            {
;;;148                return(PARAM_ERROR);
000118  200c              MOVS     r0,#0xc
                  |L1.282|
;;;149            }
;;;150        }
;;;151    
;;;152        if(param_type == NO_PARAM_CHECK)
;;;153        {
;;;154            /* further testing is not required. Verification is done in  
;;;155               related commands */
;;;156            return(0);
;;;157        }
;;;158        
;;;159        rc = is_div(*param_ptr,BY_4);
;;;160        if( rc != 0)
;;;161        {   
;;;162            if(param_type == COUNT)
;;;163            {
;;;164                return_code = COUNT_ERROR;
;;;165            }
;;;166            else
;;;167            {
;;;168                return_code = ADDR_ERROR;
;;;169                /* Now distinguish between SRC & DST if required */
;;;170                if(param_type == RAM_ADDRESS)
;;;171                {
;;;172                    return_code = SRC_ADDR_ERROR;
;;;173                }
;;;174                if(param_type == FLASH_ADDRESS)
;;;175                {
;;;176                    return_code = DST_ADDR_ERROR;
;;;177                }
;;;178            } /* Address error */
;;;179        } /* is_div by 4 error */
;;;180    
;;;181        /* Check for address mapping if required. Each type of address requires a 
;;;182        different type of test. Do this testing only if previous test is ok */
;;;183        if(return_code == 0)
;;;184        {
;;;185            if( ((*param_ptr >= RAM_START) && ((*param_ptr+count) <= (RAM_END+1))) )
;;;186            {
;;;187                in_ram = TRUE;
;;;188            }
;;;189            else
;;;190            {
;;;191                in_ram = FALSE;
;;;192            }
;;;193            if( ((*param_ptr >= USER_START_SECTOR_ADDRESS) && ((*param_ptr+count) <= (USER_END_SECTOR_ADDRESS+1))) )
;;;194            {
;;;195                in_flash = TRUE;
;;;196            }
;;;197            else
;;;198            {
;;;199                in_flash = FALSE;
;;;200            }
;;;201            if(param_type == RAM_OR_FLASH_ADDRESS)
;;;202            {
;;;203                if( !(in_ram || in_flash) )
;;;204                {
;;;205                    return_code = ADDR_NOT_MAPPED;
;;;206                }
;;;207            }
;;;208            if(param_type == RAM_ADDRESS)
;;;209            {
;;;210                if( !(in_ram) )
;;;211                {
;;;212                    return_code = SRC_ADDR_NOT_MAPPED;
;;;213                }
;;;214            }
;;;215        }
;;;216        return(return_code);
;;;217    }/* param_check */
00011a  b006              ADD      sp,sp,#0x18
00011c  bcf0              POP      {r4-r7}
00011e  bc08              POP      {r3}
000120  4718              BX       r3
                  |L1.290|
000122  2c69              CMP      r4,#0x69              ;152
000124  d101              BNE      |L1.298|
000126  2000              MOVS     r0,#0                 ;156
000128  e7f7              B        |L1.282|
                  |L1.298|
00012a  2104              MOVS     r1,#4                 ;159
00012c  6828              LDR      r0,[r5,#0]            ;159
00012e  f7fffffe          BL       is_div
000132  0006              MOVS     r6,r0                 ;159
000134  2e00              CMP      r6,#0                 ;160
000136  d00e              BEQ      |L1.342|
000138  2c64              CMP      r4,#0x64              ;162
00013a  d102              BNE      |L1.322|
00013c  2006              MOVS     r0,#6                 ;164
00013e  9001              STR      r0,[sp,#4]            ;164
000140  e009              B        |L1.342|
                  |L1.322|
000142  200d              MOVS     r0,#0xd               ;168
000144  9001              STR      r0,[sp,#4]            ;168
000146  2c67              CMP      r4,#0x67              ;170
000148  d101              BNE      |L1.334|
00014a  2002              MOVS     r0,#2                 ;172
00014c  9001              STR      r0,[sp,#4]            ;172
                  |L1.334|
00014e  2c68              CMP      r4,#0x68              ;174
000150  d101              BNE      |L1.342|
000152  2003              MOVS     r0,#3                 ;176
000154  9001              STR      r0,[sp,#4]            ;176
                  |L1.342|
000156  9801              LDR      r0,[sp,#4]            ;183
000158  2800              CMP      r0,#0                 ;183
00015a  d12d              BNE      |L1.440|
00015c  2101              MOVS     r1,#1                 ;185
00015e  0789              LSLS     r1,r1,#30             ;185
000160  6828              LDR      r0,[r5,#0]            ;185
000162  4288              CMP      r0,r1                 ;185
000164  d307              BCC      |L1.374|
000166  6829              LDR      r1,[r5,#0]            ;185
000168  9805              LDR      r0,[sp,#0x14]         ;185
00016a  1808              ADDS     r0,r1,r0              ;185
00016c  49d4              LDR      r1,|L1.1216|
00016e  4288              CMP      r0,r1                 ;185
000170  d801              BHI      |L1.374|
000172  2701              MOVS     r7,#1                 ;187
000174  e000              B        |L1.376|
                  |L1.374|
000176  2700              MOVS     r7,#0                 ;191
                  |L1.376|
000178  2101              MOVS     r1,#1                 ;193
00017a  0349              LSLS     r1,r1,#13             ;193
00017c  6828              LDR      r0,[r5,#0]            ;193
00017e  4288              CMP      r0,r1                 ;193
000180  d309              BCC      |L1.406|
000182  6829              LDR      r1,[r5,#0]            ;193
000184  9805              LDR      r0,[sp,#0x14]         ;193
000186  1808              ADDS     r0,r1,r0              ;193
000188  213f              MOVS     r1,#0x3f              ;193
00018a  0349              LSLS     r1,r1,#13             ;193
00018c  4288              CMP      r0,r1                 ;193
00018e  d802              BHI      |L1.406|
000190  2001              MOVS     r0,#1                 ;195
000192  9000              STR      r0,[sp,#0]            ;195
000194  e001              B        |L1.410|
                  |L1.406|
000196  2000              MOVS     r0,#0                 ;199
000198  9000              STR      r0,[sp,#0]            ;199
                  |L1.410|
00019a  2c66              CMP      r4,#0x66              ;201
00019c  d106              BNE      |L1.428|
00019e  2f00              CMP      r7,#0                 ;203
0001a0  d104              BNE      |L1.428|
0001a2  9800              LDR      r0,[sp,#0]            ;203
0001a4  2800              CMP      r0,#0                 ;203
0001a6  d101              BNE      |L1.428|
0001a8  200e              MOVS     r0,#0xe               ;205
0001aa  9001              STR      r0,[sp,#4]            ;205
                  |L1.428|
0001ac  2c67              CMP      r4,#0x67              ;208
0001ae  d103              BNE      |L1.440|
0001b0  2f00              CMP      r7,#0                 ;210
0001b2  d101              BNE      |L1.440|
0001b4  2004              MOVS     r0,#4                 ;212
0001b6  9001              STR      r0,[sp,#4]            ;212
                  |L1.440|
0001b8  9801              LDR      r0,[sp,#4]            ;216
0001ba  e7ae              B        |L1.282|
;;;218    
                          ENDP

                  iap_entry PROC
;;;219    void iap_entry(unsigned param_tab[],unsigned result_tab[])
0001bc  b570              PUSH     {r4-r6,lr}
;;;220    {
0001be  0004              MOVS     r4,r0
0001c0  000d              MOVS     r5,r1
;;;221        void (*iap)(unsigned [],unsigned []);
;;;222    
;;;223        iap = (void (*)(unsigned [],unsigned []))IAP_ADDRESS;
0001c2  4ec0              LDR      r6,|L1.1220|
;;;224        iap(param_tab,result_tab);
0001c4  0029              MOVS     r1,r5
0001c6  0020              MOVS     r0,r4
0001c8  f7fffffe          BL       __ARM_common_call_via_r6
;;;225    }
0001cc  bc70              POP      {r4-r6}
0001ce  bc08              POP      {r3}
0001d0  4718              BX       r3
;;;226    
                          ENDP

                  decode PROC
;;;227    char decode(char c)
0001d2  0001              MOVS     r1,r0
;;;228    {
;;;229        if(c == 0x60)
0001d4  2960              CMP      r1,#0x60
0001d6  d101              BNE      |L1.476|
;;;230        {
;;;231            return(0x00);
0001d8  2000              MOVS     r0,#0
                  |L1.474|
;;;232        }
;;;233        else
;;;234        {
;;;235            return(c - SP);
;;;236        }
;;;237    }
0001da  4770              BX       lr
                  |L1.476|
0001dc  0008              MOVS     r0,r1                 ;235
0001de  3820              SUBS     r0,r0,#0x20           ;235
0001e0  0600              LSLS     r0,r0,#24             ;235
0001e2  0e00              LSRS     r0,r0,#24             ;235
0001e4  e7f9              B        |L1.474|
;;;238    
                          ENDP

                  uudecode PROC
;;;239    unsigned uudecode(char * inbuf, char * outbuf, int * count)
0001e6  b5f7              PUSH     {r0-r2,r4-r7,lr}
;;;240    {
0001e8  0003              MOVS     r3,r0
0001ea  000c              MOVS     r4,r1
;;;241        unsigned sum;
;;;242        int in_byte_count,out_byte_count;
;;;243        
;;;244        sum=0;
0001ec  2500              MOVS     r5,#0
;;;245        out_byte_count=0;
0001ee  2600              MOVS     r6,#0
;;;246        in_byte_count = decode(*inbuf);
0001f0  7818              LDRB     r0,[r3,#0]
0001f2  f7fffffe          BL       decode
0001f6  0002              MOVS     r2,r0
;;;247        /* Do not decode if byte count is > 45 */
;;;248        if( (in_byte_count > 0) && (in_byte_count <= UU_LINE) )
0001f8  2a00              CMP      r2,#0
0001fa  dd4d              BLE      |L1.664|
0001fc  2a2d              CMP      r2,#0x2d
0001fe  dc4b              BGT      |L1.664|
;;;249        {
;;;250            for (++inbuf; in_byte_count > 0; inbuf += 4, in_byte_count -= 3)
000200  1c5b              ADDS     r3,r3,#1
000202  e047              B        |L1.660|
                  |L1.516|
;;;251            {
;;;252                /* !!! Test for valid printable character is not done !!! */
;;;253                if(in_byte_count >= 3)
000204  2a03              CMP      r2,#3
000206  db25              BLT      |L1.596|
;;;254                {
;;;255                    outbuf[0] = (decode(inbuf[0]) << 2) | (decode(inbuf[1]) >> 4);
000208  7818              LDRB     r0,[r3,#0]
00020a  f7fffffe          BL       decode
00020e  0087              LSLS     r7,r0,#2
000210  7858              LDRB     r0,[r3,#1]
000212  f7fffffe          BL       decode
000216  1100              ASRS     r0,r0,#4
000218  4307              ORRS     r7,r7,r0
00021a  7027              STRB     r7,[r4,#0]
;;;256                    outbuf[1] = (decode(inbuf[1]) << 4) | (decode(inbuf[2]) >> 2);
00021c  7858              LDRB     r0,[r3,#1]
00021e  f7fffffe          BL       decode
000222  0107              LSLS     r7,r0,#4
000224  7898              LDRB     r0,[r3,#2]
000226  f7fffffe          BL       decode
00022a  1080              ASRS     r0,r0,#2
00022c  4307              ORRS     r7,r7,r0
00022e  7067              STRB     r7,[r4,#1]
;;;257                    outbuf[2] = (decode(inbuf[2]) << 6) | (decode(inbuf[3]));
000230  7898              LDRB     r0,[r3,#2]
000232  f7fffffe          BL       decode
000236  0187              LSLS     r7,r0,#6
000238  78d8              LDRB     r0,[r3,#3]
00023a  f7fffffe          BL       decode
00023e  4307              ORRS     r7,r7,r0
000240  70a7              STRB     r7,[r4,#2]
;;;258                    out_byte_count += 3;
000242  1cf6              ADDS     r6,r6,#3
;;;259                    sum = sum + outbuf[0] + outbuf[1] + outbuf[2];
000244  7820              LDRB     r0,[r4,#0]
000246  1940              ADDS     r0,r0,r5
000248  7861              LDRB     r1,[r4,#1]
00024a  1840              ADDS     r0,r0,r1
00024c  78a1              LDRB     r1,[r4,#2]
00024e  1845              ADDS     r5,r0,r1
;;;260                    outbuf+=3;
000250  1ce4              ADDS     r4,r4,#3
000252  e01d              B        |L1.656|
                  |L1.596|
;;;261                }
;;;262                else
;;;263                {
;;;264                     if(in_byte_count >= 1)
000254  2a01              CMP      r2,#1
000256  db0c              BLT      |L1.626|
;;;265                    {
;;;266                        outbuf[0] = (decode(inbuf[0]) << 2) | (decode(inbuf[1]) >> 4);
000258  7818              LDRB     r0,[r3,#0]
00025a  f7fffffe          BL       decode
00025e  0087              LSLS     r7,r0,#2
000260  7858              LDRB     r0,[r3,#1]
000262  f7fffffe          BL       decode
000266  1100              ASRS     r0,r0,#4
000268  4307              ORRS     r7,r7,r0
00026a  7027              STRB     r7,[r4,#0]
;;;267                        out_byte_count++;
00026c  1c76              ADDS     r6,r6,#1
;;;268                        sum = sum + outbuf[0];
00026e  7820              LDRB     r0,[r4,#0]
000270  1945              ADDS     r5,r0,r5
                  |L1.626|
;;;269                      /* No need to increment the outbuf as this is the last for loop iteration */
;;;270                    }
;;;271                    if(in_byte_count >= 2)
000272  2a02              CMP      r2,#2
000274  db0c              BLT      |L1.656|
;;;272                    {
;;;273                        outbuf[1] = (decode(inbuf[1]) << 4) | (decode(inbuf[2]) >> 2);
000276  7858              LDRB     r0,[r3,#1]
000278  f7fffffe          BL       decode
00027c  0107              LSLS     r7,r0,#4
00027e  7898              LDRB     r0,[r3,#2]
000280  f7fffffe          BL       decode
000284  1080              ASRS     r0,r0,#2
000286  4307              ORRS     r7,r7,r0
000288  7067              STRB     r7,[r4,#1]
;;;274                        out_byte_count++;
00028a  1c76              ADDS     r6,r6,#1
;;;275                        sum = sum + outbuf[1];
00028c  7860              LDRB     r0,[r4,#1]
00028e  1945              ADDS     r5,r0,r5
                  |L1.656|
000290  1d1b              ADDS     r3,r3,#4              ;250
000292  1ed2              SUBS     r2,r2,#3              ;250
                  |L1.660|
000294  2a00              CMP      r2,#0                 ;250
000296  dcb5              BGT      |L1.516|
                  |L1.664|
;;;276                      /* No need to increment the outbuf as this is the last for loop iteration */
;;;277                    }
;;;278                }
;;;279            } /* for loop */
;;;280        }
;;;281        *count = out_byte_count;
000298  9802              LDR      r0,[sp,#8]
00029a  6006              STR      r6,[r0,#0]
;;;282        return(sum);
00029c  0028              MOVS     r0,r5
;;;283    } /* uudecode */
00029e  bcfe              POP      {r1-r7}
0002a0  bc08              POP      {r3}
0002a2  4718              BX       r3
;;;284    
                          ENDP

                  encode PROC
;;;285    char encode(char c)
0002a4  0001              MOVS     r1,r0
;;;286    {
;;;287        if( c == 0x00)
0002a6  2900              CMP      r1,#0
0002a8  d101              BNE      |L1.686|
;;;288        {
;;;289            return(0x60);
0002aa  2060              MOVS     r0,#0x60
                  |L1.684|
;;;290        }
;;;291        else
;;;292        {
;;;293            return(c+SP);
;;;294        }
;;;295    }
0002ac  4770              BX       lr
                  |L1.686|
0002ae  0008              MOVS     r0,r1                 ;293
0002b0  3020              ADDS     r0,r0,#0x20           ;293
0002b2  0600              LSLS     r0,r0,#24             ;293
0002b4  0e00              LSRS     r0,r0,#24             ;293
0002b6  e7f9              B        |L1.684|
;;;296    
                          ENDP

                  uuencode PROC
;;;297    unsigned uuencode(char * inbuf, char * outbuf, int count)
0002b8  b5f8              PUSH     {r3-r7,lr}
;;;298    {
0002ba  0003              MOVS     r3,r0
0002bc  000c              MOVS     r4,r1
;;;299        unsigned sum;
;;;300        char byte1,byte2;
;;;301        sum = 0;
0002be  2500              MOVS     r5,#0
;;;302        *outbuf = encode(count);
0002c0  0610              LSLS     r0,r2,#24
0002c2  0e00              LSRS     r0,r0,#24
0002c4  f7fffffe          BL       encode
0002c8  7020              STRB     r0,[r4,#0]
;;;303        outbuf++;
0002ca  1c64              ADDS     r4,r4,#1
;;;304        while(count>0)
0002cc  e039              B        |L1.834|
                  |L1.718|
;;;305        {
;;;306            if(count >= 3)
0002ce  2a03              CMP      r2,#3
0002d0  db08              BLT      |L1.740|
;;;307            {
;;;308                byte1 = inbuf[1];
0002d2  785e              LDRB     r6,[r3,#1]
;;;309                byte2 = inbuf[2];
0002d4  789f              LDRB     r7,[r3,#2]
;;;310                sum = sum + inbuf[0] + inbuf[1] + inbuf[2];
0002d6  7818              LDRB     r0,[r3,#0]
0002d8  1940              ADDS     r0,r0,r5
0002da  7859              LDRB     r1,[r3,#1]
0002dc  1840              ADDS     r0,r0,r1
0002de  7899              LDRB     r1,[r3,#2]
0002e0  1845              ADDS     r5,r0,r1
0002e2  e00c              B        |L1.766|
                  |L1.740|
;;;311            }
;;;312            else
;;;313            {
;;;314                if(count == 2)
0002e4  2a02              CMP      r2,#2
0002e6  d106              BNE      |L1.758|
;;;315                {
;;;316                    byte1 = inbuf[1];
0002e8  785e              LDRB     r6,[r3,#1]
;;;317                    byte2 = inbuf[1];
0002ea  785f              LDRB     r7,[r3,#1]
;;;318                    sum = sum + inbuf[0] + inbuf[1];
0002ec  7818              LDRB     r0,[r3,#0]
0002ee  1940              ADDS     r0,r0,r5
0002f0  7859              LDRB     r1,[r3,#1]
0002f2  1845              ADDS     r5,r0,r1
0002f4  e003              B        |L1.766|
                  |L1.758|
;;;319                }
;;;320                else
;;;321                {
;;;322                    byte1 = inbuf[0];
0002f6  781e              LDRB     r6,[r3,#0]
;;;323                    byte2 = inbuf[0];
0002f8  781f              LDRB     r7,[r3,#0]
;;;324                    sum = sum + inbuf[0];
0002fa  7818              LDRB     r0,[r3,#0]
0002fc  1945              ADDS     r5,r0,r5
                  |L1.766|
;;;325                }
;;;326            }
;;;327            outbuf[0] = encode(((inbuf[0] >> 2) & 0x3F));
0002fe  7819              LDRB     r1,[r3,#0]
000300  1088              ASRS     r0,r1,#2
000302  f7fffffe          BL       encode
000306  7020              STRB     r0,[r4,#0]
;;;328            outbuf[1] = encode(((inbuf[0] & 0x03) << 4) + ((byte1 & 0xF0) >> 4));
000308  7818              LDRB     r0,[r3,#0]
00030a  0780              LSLS     r0,r0,#30
00030c  0e80              LSRS     r0,r0,#26
00030e  21f0              MOVS     r1,#0xf0
000310  4031              ANDS     r1,r1,r6
000312  1109              ASRS     r1,r1,#4
000314  1840              ADDS     r0,r0,r1
000316  9000              STR      r0,[sp,#0]
000318  f7fffffe          BL       encode
00031c  7060              STRB     r0,[r4,#1]
;;;329            outbuf[2] = encode(((byte1 & 0x0F) << 2) + ((byte2 & 0xC0) >> 6));
00031e  0730              LSLS     r0,r6,#28
000320  0e80              LSRS     r0,r0,#26
000322  21c0              MOVS     r1,#0xc0
000324  4039              ANDS     r1,r1,r7
000326  1189              ASRS     r1,r1,#6
000328  1840              ADDS     r0,r0,r1
00032a  9000              STR      r0,[sp,#0]
00032c  f7fffffe          BL       encode
000330  70a0              STRB     r0,[r4,#2]
;;;330            outbuf[3] = encode((byte2 & 0x3F));
000332  06b8              LSLS     r0,r7,#26
000334  0e80              LSRS     r0,r0,#26
000336  f7fffffe          BL       encode
00033a  70e0              STRB     r0,[r4,#3]
;;;331            outbuf+=4;
00033c  1d24              ADDS     r4,r4,#4
;;;332            inbuf+=3;
00033e  1cdb              ADDS     r3,r3,#3
;;;333            count-=3;
000340  1ed2              SUBS     r2,r2,#3
                  |L1.834|
000342  2a00              CMP      r2,#0                 ;304
000344  dcc3              BGT      |L1.718|
;;;334        } /* while loop */
;;;335        outbuf[0] = NUL;
000346  2000              MOVS     r0,#0
000348  7020              STRB     r0,[r4,#0]
;;;336        return(sum);
00034a  0028              MOVS     r0,r5
;;;337    } /* uuencode */
00034c  bcf8              POP      {r3-r7}
00034e  bc08              POP      {r3}
000350  4718              BX       r3
;;;338    
                          ENDP

                  write_to_ram PROC
;;;342    
;;;343    void write_to_ram(void)
000352  b5f0              PUSH     {r4-r7,lr}
;;;344    {
000354  b087              SUB      sp,sp,#0x1c
;;;345        unsigned dst,checksum,recvd_checksum;
;;;346        unsigned line_ctr,last_dst;
;;;347        int count,decode_count,last_cnt,char_cnt;
;;;348        unsigned rc;
;;;349        
;;;350        /* Check count validity first as mapping check requires count */
;;;351        rc = param_check(param_buf[ISP_PARAM_2],(unsigned *)&count,COUNT,count);
000356  495c              LDR      r1,|L1.1224|
000358  6888              LDR      r0,[r1,#8]  ; param_buf
00035a  2264              MOVS     r2,#0x64
00035c  a904              ADD      r1,sp,#0x10
00035e  9b04              LDR      r3,[sp,#0x10]
000360  f7fffffe          BL       param_check
000364  0004              MOVS     r4,r0
;;;352        if(rc == 0)
000366  2c00              CMP      r4,#0
000368  d10d              BNE      |L1.902|
;;;353        {
;;;354            rc = param_check(param_buf[ISP_PARAM_1],&dst,RAM_ADDRESS,count);
00036a  4957              LDR      r1,|L1.1224|
00036c  6848              LDR      r0,[r1,#4]  ; param_buf
00036e  2267              MOVS     r2,#0x67
000370  a906              ADD      r1,sp,#0x18
000372  9b04              LDR      r3,[sp,#0x10]
000374  f7fffffe          BL       param_check
000378  0004              MOVS     r4,r0
;;;355            if (rc == SRC_ADDR_NOT_MAPPED)
00037a  2c04              CMP      r4,#4
00037c  d100              BNE      |L1.896|
;;;356            {
;;;357                rc = ADDR_NOT_MAPPED;
00037e  240e              MOVS     r4,#0xe
                  |L1.896|
;;;358            }
;;;359            if (rc == SRC_ADDR_ERROR)
000380  2c02              CMP      r4,#2
000382  d100              BNE      |L1.902|
;;;360            {
;;;361                rc = ADDR_ERROR;
000384  240d              MOVS     r4,#0xd
                  |L1.902|
;;;362            }
;;;363        }
;;;364        /* Do not allow write to ISP RAM variable area */
;;;365        if( (crp_after_reset == CRP1) )
000386  4851              LDR      r0,|L1.1228|
000388  6800              LDR      r0,[r0,#0]  ; crp_after_reset
00038a  4951              LDR      r1,|L1.1232|
00038c  4288              CMP      r0,r1
00038e  d105              BNE      |L1.924|
;;;366        {
;;;367             if( ( dst < (RAM_START) ) )
000390  2101              MOVS     r1,#1
000392  0789              LSLS     r1,r1,#30
000394  9806              LDR      r0,[sp,#0x18]
000396  4288              CMP      r0,r1
000398  d200              BCS      |L1.924|
;;;368             {
;;;369                 rc = CODE_READ_PROTECTION_ENABLED;
00039a  2413              MOVS     r4,#0x13
                  |L1.924|
;;;370             }
;;;371         }
;;;372     
;;;373        /* Print command result on serial channel */
;;;374        sendline_crlf(i_to_a(rc,param_buf[ISP_PARAM_0],PARAM_SIZE));
00039c  484a              LDR      r0,|L1.1224|
00039e  220f              MOVS     r2,#0xf
0003a0  6801              LDR      r1,[r0,#0]  ; param_buf
0003a2  0020              MOVS     r0,r4
0003a4  f7fffffe          BL       i_to_a
0003a8  9000              STR      r0,[sp,#0]
0003aa  f7fffffe          BL       sendline_crlf
;;;375    
;;;376        /* execute command only if parameters are ok */
;;;377        if(rc != CMD_SUCCESS)
0003ae  2c00              CMP      r4,#0
0003b0  d003              BEQ      |L1.954|
                  |L1.946|
;;;378        {
;;;379            return;
;;;380        }
;;;381        
;;;382        /* Initialize checksum related variables */
;;;383        checksum = 0;
;;;384        line_ctr = 0;
;;;385        last_dst = dst;
;;;386        last_cnt = count;
;;;387        while(count>0)
;;;388        {
;;;389            if(getline(cmd_buf,CMD_SIZE,&char_cnt) != CMD_SUCCESS)
;;;390            {
;;;391                /* Abort command */
;;;392                break;
;;;393            }
;;;394            /* Keep track of number of lines decoded. Need to verify checksum
;;;395               once the LINE_CHECKSUM lines are receieved */
;;;396            if(char_cnt != 0) /* Ignore empty lines */
;;;397            {
;;;398                line_ctr++;
;;;399                checksum = checksum + uudecode(cmd_buf,(char *)dst,&decode_count);
;;;400                dst = dst + decode_count;
;;;401                count = count - decode_count;
;;;402            }
;;;403            /* Need checksum handshake ? */
;;;404            if( ((line_ctr == LINE_CHECKSUM) || (count == 0)) )
;;;405            {
;;;406                char_cnt = 0;
;;;407                /* Get checksum string (ASCII decimal) from host */
;;;408                while(char_cnt == 0)
;;;409                {
;;;410                    rc = getline(cmd_buf,CMD_SIZE,&char_cnt);
;;;411                }
;;;412                if( rc != CMD_SUCCESS)
;;;413                {
;;;414                    break;
;;;415                }
;;;416                /* No error check while conversion to integer. If there is an error
;;;417                it will be trapped by wrong checksum */
;;;418                a_to_i(cmd_buf,&recvd_checksum);
;;;419                if( checksum == recvd_checksum)
;;;420                {
;;;421                    last_cnt = count;
;;;422                    last_dst = dst;
;;;423                    sendline_crlf((char *)ok);
;;;424                }
;;;425                else
;;;426                {
;;;427                    count = last_cnt;
;;;428                    dst = last_dst;
;;;429                    sendline_crlf((char *)resend);
;;;430                }
;;;431                /* line counter and checksum has to be reset anyway */
;;;432                line_ctr = 0;
;;;433                checksum = 0;
;;;434            }
;;;435        }/* While loop */
;;;436    } /* write_to_ram */
0003b2  b007              ADD      sp,sp,#0x1c
0003b4  bcf0              POP      {r4-r7}
0003b6  bc08              POP      {r3}
0003b8  4718              BX       r3
                  |L1.954|
0003ba  2500              MOVS     r5,#0                 ;383
0003bc  2600              MOVS     r6,#0                 ;384
0003be  9f06              LDR      r7,[sp,#0x18]         ;385
0003c0  9804              LDR      r0,[sp,#0x10]         ;386
0003c2  9002              STR      r0,[sp,#8]            ;386
0003c4  e043              B        |L1.1102|
                  |L1.966|
0003c6  aa01              ADD      r2,sp,#4              ;389
0003c8  2146              MOVS     r1,#0x46              ;389
0003ca  483b              LDR      r0,|L1.1208|
0003cc  f7fffffe          BL       getline
0003d0  2800              CMP      r0,#0                 ;389
0003d2  d000              BEQ      |L1.982|
0003d4  e03e              B        |L1.1108|
                  |L1.982|
0003d6  9801              LDR      r0,[sp,#4]            ;396
0003d8  2800              CMP      r0,#0                 ;396
0003da  d00e              BEQ      |L1.1018|
0003dc  1c76              ADDS     r6,r6,#1              ;398
0003de  aa03              ADD      r2,sp,#0xc            ;399
0003e0  4835              LDR      r0,|L1.1208|
0003e2  9906              LDR      r1,[sp,#0x18]         ;399
0003e4  f7fffffe          BL       uudecode
0003e8  1945              ADDS     r5,r0,r5              ;399
0003ea  9903              LDR      r1,[sp,#0xc]          ;400
0003ec  9806              LDR      r0,[sp,#0x18]         ;400
0003ee  1840              ADDS     r0,r0,r1              ;400
0003f0  9006              STR      r0,[sp,#0x18]         ;400
0003f2  9903              LDR      r1,[sp,#0xc]          ;401
0003f4  9804              LDR      r0,[sp,#0x10]         ;401
0003f6  1a40              SUBS     r0,r0,r1              ;401
0003f8  9004              STR      r0,[sp,#0x10]         ;401
                  |L1.1018|
0003fa  2e14              CMP      r6,#0x14              ;404
0003fc  d002              BEQ      |L1.1028|
0003fe  9804              LDR      r0,[sp,#0x10]         ;404
000400  2800              CMP      r0,#0                 ;404
000402  d124              BNE      |L1.1102|
                  |L1.1028|
000404  2000              MOVS     r0,#0                 ;406
000406  9001              STR      r0,[sp,#4]            ;406
000408  e005              B        |L1.1046|
                  |L1.1034|
00040a  aa01              ADD      r2,sp,#4              ;410
00040c  2146              MOVS     r1,#0x46              ;410
00040e  482a              LDR      r0,|L1.1208|
000410  f7fffffe          BL       getline
000414  0004              MOVS     r4,r0                 ;410
                  |L1.1046|
000416  9801              LDR      r0,[sp,#4]            ;408
000418  2800              CMP      r0,#0                 ;408
00041a  d0f6              BEQ      |L1.1034|
00041c  2c00              CMP      r4,#0                 ;412
00041e  d000              BEQ      |L1.1058|
000420  e018              B        |L1.1108|
                  |L1.1058|
000422  a905              ADD      r1,sp,#0x14           ;418
000424  4824              LDR      r0,|L1.1208|
000426  f7fffffe          BL       a_to_i
00042a  9805              LDR      r0,[sp,#0x14]         ;419
00042c  4285              CMP      r5,r0                 ;419
00042e  d106              BNE      |L1.1086|
000430  9804              LDR      r0,[sp,#0x10]         ;421
000432  9002              STR      r0,[sp,#8]            ;421
000434  9f06              LDR      r7,[sp,#0x18]         ;422
000436  4827              LDR      r0,|L1.1236|
000438  f7fffffe          BL       sendline_crlf
00043c  e005              B        |L1.1098|
                  |L1.1086|
00043e  9802              LDR      r0,[sp,#8]            ;427
000440  9004              STR      r0,[sp,#0x10]         ;427
000442  9706              STR      r7,[sp,#0x18]         ;428
000444  4824              LDR      r0,|L1.1240|
000446  f7fffffe          BL       sendline_crlf
                  |L1.1098|
00044a  2600              MOVS     r6,#0                 ;432
00044c  2500              MOVS     r5,#0                 ;433
                  |L1.1102|
00044e  9804              LDR      r0,[sp,#0x10]         ;387
000450  2800              CMP      r0,#0                 ;387
000452  dcb8              BGT      |L1.966|
                  |L1.1108|
000454  46c0              MOV      r8,r8                 ;392
000456  46c0              MOV      r8,r8
000458  e7ab              B        |L1.946|
;;;437    
                          ENDP

                  read PROC
;;;438    void read(void)
00045a  b5f0              PUSH     {r4-r7,lr}
;;;439    {
00045c  b087              SUB      sp,sp,#0x1c
;;;440        unsigned src,checksum,last_src,line_ctr;
;;;441        int count,encode_count,last_cnt;
;;;442        unsigned rc;
;;;443    	int char_cnt;
;;;444    
;;;445        /* Check count validity first as address mapping check requires count */
;;;446        rc = param_check(param_buf[ISP_PARAM_2],(unsigned *)&count,COUNT,NUL);
00045e  491a              LDR      r1,|L1.1224|
000460  2300              MOVS     r3,#0
000462  2264              MOVS     r2,#0x64
000464  6888              LDR      r0,[r1,#8]  ; param_buf
000466  a904              ADD      r1,sp,#0x10
000468  f7fffffe          BL       param_check
00046c  0004              MOVS     r4,r0
;;;447        if(rc == 0)
00046e  2c00              CMP      r4,#0
000470  d107              BNE      |L1.1154|
;;;448        {
;;;449            rc = param_check(param_buf[ISP_PARAM_1],&src,RAM_OR_FLASH_ADDRESS,count);
000472  4915              LDR      r1,|L1.1224|
000474  6848              LDR      r0,[r1,#4]  ; param_buf
000476  2266              MOVS     r2,#0x66
000478  a906              ADD      r1,sp,#0x18
00047a  9b04              LDR      r3,[sp,#0x10]
00047c  f7fffffe          BL       param_check
000480  0004              MOVS     r4,r0
                  |L1.1154|
;;;450        }
;;;451        /* Print command result on serial channel */
;;;452        sendline_crlf(i_to_a(rc,param_buf[ISP_PARAM_0],PARAM_SIZE));
000482  4811              LDR      r0,|L1.1224|
000484  220f              MOVS     r2,#0xf
000486  6801              LDR      r1,[r0,#0]  ; param_buf
000488  0020              MOVS     r0,r4
00048a  f7fffffe          BL       i_to_a
00048e  9001              STR      r0,[sp,#4]
000490  f7fffffe          BL       sendline_crlf
;;;453        /* execute command only if parameters are ok */
;;;454        if(rc != CMD_SUCCESS)
000494  2c00              CMP      r4,#0
000496  d003              BEQ      |L1.1184|
                  |L1.1176|
;;;455        {
;;;456            return;
;;;457        }
;;;458        
;;;459        /* Initialize checksum related variables */
;;;460        checksum = 0;
;;;461        line_ctr = 0;
;;;462        last_src = src;
;;;463        last_cnt = count;
;;;464    
;;;465        while(count > 0)
;;;466        {
;;;467            if(count > UU_LINE)
;;;468            {
;;;469                encode_count = UU_LINE;
;;;470            }
;;;471            else
;;;472            {
;;;473                encode_count = count;
;;;474            }
;;;475            checksum = checksum + uuencode((char *)src,cmd_buf,encode_count);
;;;476            if(sendline_crlf(cmd_buf) != 1)
;;;477            {
;;;478                /* Abort command */
;;;479                break;
;;;480            }
;;;481            /* Keep track of number of lines encoded. Need to send checksum
;;;482               once the LINE_CHECKSUM lines are transmitted */
;;;483            line_ctr++;        
;;;484            src = src + encode_count;
;;;485            count = count - encode_count;
;;;486            if( ((line_ctr == LINE_CHECKSUM) || (count == 0)) )
;;;487            {
;;;488                /* Tranmitt checksum string (ASCII decimal) to host */
;;;489                sendline_crlf(i_to_a(checksum,cmd_buf,PARAM_SIZE));
;;;490                /* Read host response */
;;;491                rc = getline(cmd_buf,CMD_SIZE,&char_cnt);
;;;492                if( rc != CMD_SUCCESS)
;;;493                {
;;;494                    break;
;;;495                }
;;;496                if(str_cmp(cmd_buf,(char *)ok) == 0)
;;;497                {
;;;498                    last_cnt = count;
;;;499                    last_src = src;
;;;500                }
;;;501                else
;;;502                {
;;;503                    count = last_cnt;
;;;504                    src = last_src;
;;;505                }
;;;506                /* line counter and checksum has to be reset anyway */
;;;507                line_ctr = 0;
;;;508                checksum = 0;
;;;509            }
;;;510        } /* while count > 0 */
;;;511    } /* read */
000498  b007              ADD      sp,sp,#0x1c
00049a  bcf0              POP      {r4-r7}
00049c  bc08              POP      {r3}
00049e  4718              BX       r3
                  |L1.1184|
0004a0  2500              MOVS     r5,#0                 ;460
0004a2  2600              MOVS     r6,#0                 ;461
0004a4  9806              LDR      r0,[sp,#0x18]         ;462
0004a6  9005              STR      r0,[sp,#0x14]         ;462
0004a8  9804              LDR      r0,[sp,#0x10]         ;463
0004aa  9003              STR      r0,[sp,#0xc]          ;463
0004ac  e051              B        |L1.1362|
                  |L1.1198|
0004ae  9804              LDR      r0,[sp,#0x10]         ;467
0004b0  282d              CMP      r0,#0x2d              ;467
0004b2  dd13              BLE      |L1.1244|
0004b4  272d              MOVS     r7,#0x2d              ;469
0004b6  e012              B        |L1.1246|
                  |L1.1208|
                          DCD      cmd_buf
                  |L1.1212|
                          DCD      sync_str
                  |L1.1216|
                          DCD      0x40010000
                  |L1.1220|
                          DCD      0x7ffffff1
                  |L1.1224|
                          DCD      param_buf
                  |L1.1228|
                          DCD      crp_after_reset
                  |L1.1232|
                          DCD      0x12345678
                  |L1.1236|
                          DCD      ||ok||
                  |L1.1240|
                          DCD      resend
                  |L1.1244|
0004dc  9f04              LDR      r7,[sp,#0x10]         ;473
                  |L1.1246|
0004de  003a              MOVS     r2,r7                 ;475
0004e0  49fe              LDR      r1,|L1.2268|
0004e2  9806              LDR      r0,[sp,#0x18]         ;475
0004e4  f7fffffe          BL       uuencode
0004e8  1945              ADDS     r5,r0,r5              ;475
0004ea  48fc              LDR      r0,|L1.2268|
0004ec  f7fffffe          BL       sendline_crlf
0004f0  2801              CMP      r0,#1                 ;476
0004f2  d000              BEQ      |L1.1270|
0004f4  e030              B        |L1.1368|
                  |L1.1270|
0004f6  1c76              ADDS     r6,r6,#1              ;483
0004f8  9806              LDR      r0,[sp,#0x18]         ;484
0004fa  19c0              ADDS     r0,r0,r7              ;484
0004fc  9006              STR      r0,[sp,#0x18]         ;484
0004fe  9804              LDR      r0,[sp,#0x10]         ;485
000500  1bc0              SUBS     r0,r0,r7              ;485
000502  9004              STR      r0,[sp,#0x10]         ;485
000504  2e14              CMP      r6,#0x14              ;486
000506  d002              BEQ      |L1.1294|
000508  9804              LDR      r0,[sp,#0x10]         ;486
00050a  2800              CMP      r0,#0                 ;486
00050c  d121              BNE      |L1.1362|
                  |L1.1294|
00050e  220f              MOVS     r2,#0xf               ;489
000510  49f2              LDR      r1,|L1.2268|
000512  0028              MOVS     r0,r5                 ;489
000514  f7fffffe          BL       i_to_a
000518  9001              STR      r0,[sp,#4]            ;489
00051a  f7fffffe          BL       sendline_crlf
00051e  aa02              ADD      r2,sp,#8              ;491
000520  2146              MOVS     r1,#0x46              ;491
000522  48ee              LDR      r0,|L1.2268|
000524  f7fffffe          BL       getline
000528  0004              MOVS     r4,r0                 ;491
00052a  2c00              CMP      r4,#0                 ;492
00052c  d000              BEQ      |L1.1328|
00052e  e013              B        |L1.1368|
                  |L1.1328|
000530  49eb              LDR      r1,|L1.2272|
000532  48ea              LDR      r0,|L1.2268|
000534  f7fffffe          BL       str_cmp
000538  2800              CMP      r0,#0                 ;496
00053a  d104              BNE      |L1.1350|
00053c  9804              LDR      r0,[sp,#0x10]         ;498
00053e  9003              STR      r0,[sp,#0xc]          ;498
000540  9806              LDR      r0,[sp,#0x18]         ;499
000542  9005              STR      r0,[sp,#0x14]         ;499
000544  e003              B        |L1.1358|
                  |L1.1350|
000546  9803              LDR      r0,[sp,#0xc]          ;503
000548  9004              STR      r0,[sp,#0x10]         ;503
00054a  9805              LDR      r0,[sp,#0x14]         ;504
00054c  9006              STR      r0,[sp,#0x18]         ;504
                  |L1.1358|
00054e  2600              MOVS     r6,#0                 ;507
000550  2500              MOVS     r5,#0                 ;508
                  |L1.1362|
000552  9804              LDR      r0,[sp,#0x10]         ;465
000554  2800              CMP      r0,#0                 ;465
000556  dcaa              BGT      |L1.1198|
                  |L1.1368|
000558  46c0              MOV      r8,r8                 ;479
00055a  46c0              MOV      r8,r8
00055c  e79c              B        |L1.1176|
;;;512    
                          ENDP

                  go_cmd PROC
;;;513    void go_cmd(void)
00055e  b538              PUSH     {r3-r5,lr}
;;;514    {
;;;515        unsigned rc;
;;;516        void (*go)(void);
;;;517        
;;;518        if(lock == FALSE)
000560  48e0              LDR      r0,|L1.2276|
000562  6800              LDR      r0,[r0,#0]  ; lock
000564  2800              CMP      r0,#0
000566  d101              BNE      |L1.1388|
;;;519        {
;;;520            rc = CMD_SUCCESS;
000568  2400              MOVS     r4,#0
00056a  e000              B        |L1.1390|
                  |L1.1388|
;;;521        }
;;;522        else
;;;523        {
;;;524            rc = CMD_LOCKED;
00056c  240f              MOVS     r4,#0xf
                  |L1.1390|
;;;525        }
;;;526            
;;;527        if(rc == CMD_SUCCESS)
00056e  2c00              CMP      r4,#0
000570  d107              BNE      |L1.1410|
;;;528        {
;;;529            /* Convert and check Go addres */
;;;530            rc = param_check(param_buf[ISP_PARAM_1],(unsigned *)&go, \
000572  49dd              LDR      r1,|L1.2280|
000574  2300              MOVS     r3,#0
000576  2266              MOVS     r2,#0x66
000578  6848              LDR      r0,[r1,#4]  ; param_buf
00057a  4669              MOV      r1,sp
00057c  f7fffffe          BL       param_check
000580  0004              MOVS     r4,r0
                  |L1.1410|
;;;531                 RAM_OR_FLASH_ADDRESS,NUL);
;;;532        }
;;;533        
;;;534        if(rc == CMD_SUCCESS)
000582  2c00              CMP      r4,#0
000584  d114              BNE      |L1.1456|
;;;535        {
;;;536            /* Check for processor mode switch */
;;;537            if( ((*(param_buf[ISP_PARAM_2]) == 'T') || (*(param_buf[ISP_PARAM_2]) == 'A')) )
000586  48d8              LDR      r0,|L1.2280|
000588  6880              LDR      r0,[r0,#8]  ; param_buf
00058a  7800              LDRB     r0,[r0,#0]
00058c  2854              CMP      r0,#0x54
00058e  d004              BEQ      |L1.1434|
000590  48d5              LDR      r0,|L1.2280|
000592  6880              LDR      r0,[r0,#8]  ; param_buf
000594  7800              LDRB     r0,[r0,#0]
000596  2841              CMP      r0,#0x41
000598  d109              BNE      |L1.1454|
                  |L1.1434|
;;;538            {
;;;539                if(*(param_buf[ISP_PARAM_2]) == 'T')
00059a  48d3              LDR      r0,|L1.2280|
00059c  6880              LDR      r0,[r0,#8]  ; param_buf
00059e  7800              LDRB     r0,[r0,#0]
0005a0  2854              CMP      r0,#0x54
0005a2  d105              BNE      |L1.1456|
;;;540                {
;;;541                    /* ARM Thumb compiler generates BX instruction when pointer 
;;;542                    to a function is used. Set last bit of the address to 1 
;;;543                    to prevent mode switch to ARM */
;;;544                    go = (void(*)(void))( ((unsigned)(go) | 0x1) );
0005a4  2101              MOVS     r1,#1
0005a6  9800              LDR      r0,[sp,#0]
0005a8  4308              ORRS     r0,r0,r1
0005aa  9000              STR      r0,[sp,#0]
0005ac  e000              B        |L1.1456|
                  |L1.1454|
;;;545                }
;;;546                /* else For ARM mode leave last bit of the address 0 */
;;;547            }
;;;548            else
;;;549            {
;;;550                /* Mode parameter is not specified or incorrect */
;;;551                rc = PARAM_ERROR;
0005ae  240c              MOVS     r4,#0xc
                  |L1.1456|
;;;552            }
;;;553        }
;;;554        /* Print command result on serial channel */
;;;555        sendline_crlf(i_to_a(rc,param_buf[ISP_PARAM_1],PARAM_SIZE));
0005b0  48cd              LDR      r0,|L1.2280|
0005b2  220f              MOVS     r2,#0xf
0005b4  6841              LDR      r1,[r0,#4]  ; param_buf
0005b6  0020              MOVS     r0,r4
0005b8  f7fffffe          BL       i_to_a
0005bc  0005              MOVS     r5,r0
0005be  f7fffffe          BL       sendline_crlf
;;;556        /* execute command only if all the parameters are ok */
;;;557        if(rc == CMD_SUCCESS)
0005c2  2c00              CMP      r4,#0
0005c4  d104              BNE      |L1.1488|
;;;558        {
;;;559    	    /* revert any peripheral changes */
;;;560            Timer_DeInit();
0005c6  f7fffffe          BL       Timer_DeInit
;;;561            go();
0005ca  9800              LDR      r0,[sp,#0]
0005cc  f7fffffe          BL       __ARM_common_call_via_r0
                  |L1.1488|
;;;562        }
;;;563    } /* go */
0005d0  bc38              POP      {r3-r5}
0005d2  bc08              POP      {r3}
0005d4  4718              BX       r3
;;;564    
                          ENDP

                  unlock PROC
;;;565    void unlock(void)
0005d6  b538              PUSH     {r3-r5,lr}
;;;566    {
;;;567        int u_code;
;;;568        unsigned rc;
;;;569        rc = param_check(param_buf[ISP_PARAM_1],(unsigned *)&u_code,NO_PARAM_CHECK,NUL);
0005d8  49c3              LDR      r1,|L1.2280|
0005da  2300              MOVS     r3,#0
0005dc  2269              MOVS     r2,#0x69
0005de  6848              LDR      r0,[r1,#4]  ; param_buf
0005e0  4669              MOV      r1,sp
0005e2  f7fffffe          BL       param_check
0005e6  0004              MOVS     r4,r0
;;;570        /* execute command only if parameters are ok */
;;;571        if(rc == 0)
0005e8  2c00              CMP      r4,#0
0005ea  d108              BNE      |L1.1534|
;;;572        {
;;;573            if(u_code == unlock_code)
0005ec  49bf              LDR      r1,|L1.2284|
0005ee  9800              LDR      r0,[sp,#0]
0005f0  4288              CMP      r0,r1
0005f2  d103              BNE      |L1.1532|
;;;574            {
;;;575                lock = FALSE;    
0005f4  2000              MOVS     r0,#0
0005f6  49bb              LDR      r1,|L1.2276|
0005f8  6008              STR      r0,[r1,#0]  ; lock
0005fa  e000              B        |L1.1534|
                  |L1.1532|
;;;576            }
;;;577            else
;;;578            {
;;;579                rc = INVALID_CODE;
0005fc  2410              MOVS     r4,#0x10
                  |L1.1534|
;;;580            }
;;;581        }
;;;582        /* Print command result on serial channel */
;;;583        sendline_crlf(i_to_a(rc,param_buf[ISP_PARAM_1],PARAM_SIZE));
0005fe  48ba              LDR      r0,|L1.2280|
000600  220f              MOVS     r2,#0xf
000602  6841              LDR      r1,[r0,#4]  ; param_buf
000604  0020              MOVS     r0,r4
000606  f7fffffe          BL       i_to_a
00060a  0005              MOVS     r5,r0
00060c  f7fffffe          BL       sendline_crlf
;;;584    } /* unlock */
000610  bc38              POP      {r3-r5}
000612  bc08              POP      {r3}
000614  4718              BX       r3
;;;585    
                          ENDP

                  prepare_sector PROC
;;;586    void prepare_sector(void)
000616  b510              PUSH     {r4,lr}
;;;587    {
;;;588        /* Convert ascii string to integer. Do not validate sector numbers as it is
;;;589           done in IAP prepare sector for write. Parameter type is deliberately 
;;;590           set to NO_PARAM_CHECK so that param_check function just converts ascii 
;;;591           to integer 
;;;592        */
;;;593        result_table[IAP_STAT_CODE] = param_check(param_buf[ISP_PARAM_1], \
000618  49b3              LDR      r1,|L1.2280|
00061a  2300              MOVS     r3,#0
00061c  2269              MOVS     r2,#0x69
00061e  6848              LDR      r0,[r1,#4]  ; param_buf
000620  49b3              LDR      r1,|L1.2288|
000622  f7fffffe          BL       param_check
000626  49b3              LDR      r1,|L1.2292|
000628  6008              STR      r0,[r1,#0]  ; result_table
;;;594        &param_table[IAP_PARAM_0],NO_PARAM_CHECK,NUL);
;;;595    
;;;596        if( result_table[IAP_STAT_CODE] == CMD_SUCCESS )
00062a  0008              MOVS     r0,r1
00062c  6800              LDR      r0,[r0,#0]  ; result_table
00062e  2800              CMP      r0,#0
000630  d109              BNE      |L1.1606|
;;;597        {
;;;598            result_table[IAP_STAT_CODE] = param_check(param_buf[ISP_PARAM_2], \
000632  49ad              LDR      r1,|L1.2280|
000634  2300              MOVS     r3,#0
000636  2269              MOVS     r2,#0x69
000638  6888              LDR      r0,[r1,#8]  ; param_buf
00063a  49ad              LDR      r1,|L1.2288|
00063c  1d09              ADDS     r1,r1,#4
00063e  f7fffffe          BL       param_check
000642  49ac              LDR      r1,|L1.2292|
000644  6008              STR      r0,[r1,#0]  ; result_table
                  |L1.1606|
;;;599            &param_table[IAP_PARAM_1],NO_PARAM_CHECK,NUL);
;;;600        }
;;;601            
;;;602        if( result_table[IAP_STAT_CODE] == CMD_SUCCESS )
000646  48ab              LDR      r0,|L1.2292|
000648  6800              LDR      r0,[r0,#0]  ; result_table
00064a  2800              CMP      r0,#0
00064c  d108              BNE      |L1.1632|
;;;603        {
;;;604            param_table[IAP_CMD_CODE] = PREPARE_SECTOR_FOR_WRITE;
00064e  2032              MOVS     r0,#0x32
000650  49a7              LDR      r1,|L1.2288|
000652  1f09              SUBS     r1,r1,#4
000654  6008              STR      r0,[r1,#0]  ; param_table
;;;605            iap_entry(param_table,result_table);
000656  49a7              LDR      r1,|L1.2292|
000658  48a5              LDR      r0,|L1.2288|
00065a  1f00              SUBS     r0,r0,#4
00065c  f7fffffe          BL       iap_entry
                  |L1.1632|
;;;606        }
;;;607        sendline_crlf(i_to_a(result_table[IAP_STAT_CODE],param_buf[ISP_PARAM_1], \
000660  4aa1              LDR      r2,|L1.2280|
000662  6851              LDR      r1,[r2,#4]  ; param_buf
000664  4aa3              LDR      r2,|L1.2292|
000666  6810              LDR      r0,[r2,#0]  ; result_table
000668  220f              MOVS     r2,#0xf
00066a  f7fffffe          BL       i_to_a
00066e  0004              MOVS     r4,r0
000670  f7fffffe          BL       sendline_crlf
;;;608        PARAM_SIZE));
;;;609    } /* prepare_sector */
000674  bc10              POP      {r4}
000676  bc08              POP      {r3}
000678  4718              BX       r3
;;;610    
                          ENDP

                  copy PROC
;;;611    void copy(void)
00067a  b510              PUSH     {r4,lr}
;;;612    {
;;;613        if(lock == TRUE)
00067c  4899              LDR      r0,|L1.2276|
00067e  6800              LDR      r0,[r0,#0]  ; lock
000680  2801              CMP      r0,#1
000682  d109              BNE      |L1.1688|
;;;614        {
;;;615            sendline_crlf(i_to_a(CMD_LOCKED,param_buf[ISP_PARAM_1],PARAM_SIZE));
000684  4898              LDR      r0,|L1.2280|
000686  220f              MOVS     r2,#0xf
000688  6841              LDR      r1,[r0,#4]  ; param_buf
00068a  0010              MOVS     r0,r2
00068c  f7fffffe          BL       i_to_a
000690  0004              MOVS     r4,r0
000692  f7fffffe          BL       sendline_crlf
000696  e04d              B        |L1.1844|
                  |L1.1688|
;;;616        }
;;;617        else
;;;618        {
;;;619        /* Convert ascii string to integer. Do not validate sector numbers as it is
;;;620        done in IAP copy RAM to FLASH.Parameter type is deliberately 
;;;621        set to NO_PARAM_CHECK so that param_check function just converts ascii to integer
;;;622        */
;;;623            result_table[IAP_STAT_CODE] = param_check(param_buf[ISP_PARAM_1], \
000698  4993              LDR      r1,|L1.2280|
00069a  2300              MOVS     r3,#0
00069c  2269              MOVS     r2,#0x69
00069e  6848              LDR      r0,[r1,#4]  ; param_buf
0006a0  4993              LDR      r1,|L1.2288|
0006a2  f7fffffe          BL       param_check
0006a6  4993              LDR      r1,|L1.2292|
0006a8  6008              STR      r0,[r1,#0]  ; result_table
;;;624            &param_table[IAP_PARAM_0],NO_PARAM_CHECK,NUL);
;;;625    
;;;626            if( result_table[IAP_STAT_CODE] == CMD_SUCCESS )
0006aa  0008              MOVS     r0,r1
0006ac  6800              LDR      r0,[r0,#0]  ; result_table
0006ae  2800              CMP      r0,#0
0006b0  d109              BNE      |L1.1734|
;;;627            {
;;;628                result_table[IAP_STAT_CODE] = param_check(param_buf[ISP_PARAM_2], \
0006b2  498d              LDR      r1,|L1.2280|
0006b4  2300              MOVS     r3,#0
0006b6  2269              MOVS     r2,#0x69
0006b8  6888              LDR      r0,[r1,#8]  ; param_buf
0006ba  498d              LDR      r1,|L1.2288|
0006bc  1d09              ADDS     r1,r1,#4
0006be  f7fffffe          BL       param_check
0006c2  498c              LDR      r1,|L1.2292|
0006c4  6008              STR      r0,[r1,#0]  ; result_table
                  |L1.1734|
;;;629                &param_table[IAP_PARAM_1],NO_PARAM_CHECK,NUL);
;;;630            }
;;;631    
;;;632            if( result_table[IAP_STAT_CODE] == CMD_SUCCESS )
0006c6  488b              LDR      r0,|L1.2292|
0006c8  6800              LDR      r0,[r0,#0]  ; result_table
0006ca  2800              CMP      r0,#0
0006cc  d109              BNE      |L1.1762|
;;;633            {
;;;634                result_table[IAP_STAT_CODE] = param_check(param_buf[ISP_PARAM_3], \
0006ce  4986              LDR      r1,|L1.2280|
0006d0  2300              MOVS     r3,#0
0006d2  2269              MOVS     r2,#0x69
0006d4  68c8              LDR      r0,[r1,#0xc]  ; param_buf
0006d6  4986              LDR      r1,|L1.2288|
0006d8  3108              ADDS     r1,r1,#8
0006da  f7fffffe          BL       param_check
0006de  4985              LDR      r1,|L1.2292|
0006e0  6008              STR      r0,[r1,#0]  ; result_table
                  |L1.1762|
;;;635                &param_table[IAP_PARAM_2],NO_PARAM_CHECK,NUL);
;;;636            }
;;;637    
;;;638            /* Do not allow write to USER Start sector */
;;;639            if( (crp_after_reset == CRP1) )
0006e2  4885              LDR      r0,|L1.2296|
0006e4  6800              LDR      r0,[r0,#0]  ; crp_after_reset
0006e6  4985              LDR      r1,|L1.2300|
0006e8  4288              CMP      r0,r1
0006ea  d109              BNE      |L1.1792|
;;;640            {
;;;641                if( (param_table[IAP_PARAM_0] < (USER_START_SECTOR_ADDRESS+USER_START_SECTOR_SIZE)) )
0006ec  4880              LDR      r0,|L1.2288|
0006ee  1f00              SUBS     r0,r0,#4
0006f0  6840              LDR      r0,[r0,#4]  ; param_table
0006f2  2103              MOVS     r1,#3
0006f4  0309              LSLS     r1,r1,#12
0006f6  4288              CMP      r0,r1
0006f8  d202              BCS      |L1.1792|
;;;642                {
;;;643                    result_table[IAP_STAT_CODE] = CODE_READ_PROTECTION_ENABLED;
0006fa  2013              MOVS     r0,#0x13
0006fc  497d              LDR      r1,|L1.2292|
0006fe  6008              STR      r0,[r1,#0]  ; result_table
                  |L1.1792|
;;;644                }
;;;645            }
;;;646    
;;;647            if( result_table[IAP_STAT_CODE] == CMD_SUCCESS )
000700  487c              LDR      r0,|L1.2292|
000702  6800              LDR      r0,[r0,#0]  ; result_table
000704  2800              CMP      r0,#0
000706  d10b              BNE      |L1.1824|
;;;648            {
;;;649                param_table[IAP_CMD_CODE] = COPY_RAM_TO_FLASH;
000708  2033              MOVS     r0,#0x33
00070a  4979              LDR      r1,|L1.2288|
00070c  1f09              SUBS     r1,r1,#4
00070e  6008              STR      r0,[r1,#0]  ; param_table
;;;650                param_table[IAP_PARAM_3] = fcclk_KHz;
000710  487b              LDR      r0,|L1.2304|
000712  6800              LDR      r0,[r0,#0]  ; fcclk_KHz
000714  6108              STR      r0,[r1,#0x10]  ; param_table
;;;651                iap_entry(param_table,result_table);
000716  4977              LDR      r1,|L1.2292|
000718  4875              LDR      r0,|L1.2288|
00071a  1f00              SUBS     r0,r0,#4
00071c  f7fffffe          BL       iap_entry
                  |L1.1824|
;;;652            }
;;;653            sendline_crlf(i_to_a(result_table[IAP_STAT_CODE],param_buf[ISP_PARAM_1], \
000720  4a71              LDR      r2,|L1.2280|
000722  6851              LDR      r1,[r2,#4]  ; param_buf
000724  4a73              LDR      r2,|L1.2292|
000726  6810              LDR      r0,[r2,#0]  ; result_table
000728  220f              MOVS     r2,#0xf
00072a  f7fffffe          BL       i_to_a
00072e  0004              MOVS     r4,r0
000730  f7fffffe          BL       sendline_crlf
                  |L1.1844|
;;;654            PARAM_SIZE));
;;;655        }
;;;656    } /* copy */
000734  bc10              POP      {r4}
000736  bc08              POP      {r3}
000738  4718              BX       r3
;;;657    
                          ENDP

                  erase PROC
;;;658    void erase(void)
00073a  b510              PUSH     {r4,lr}
;;;659    {
;;;660        if(lock == TRUE)
00073c  4869              LDR      r0,|L1.2276|
00073e  6800              LDR      r0,[r0,#0]  ; lock
000740  2801              CMP      r0,#1
000742  d109              BNE      |L1.1880|
;;;661        {
;;;662            sendline_crlf(i_to_a(CMD_LOCKED,param_buf[ISP_PARAM_1],PARAM_SIZE));
000744  4868              LDR      r0,|L1.2280|
000746  220f              MOVS     r2,#0xf
000748  6841              LDR      r1,[r0,#4]  ; param_buf
00074a  0010              MOVS     r0,r2
00074c  f7fffffe          BL       i_to_a
000750  0004              MOVS     r4,r0
000752  f7fffffe          BL       sendline_crlf
000756  e067              B        |L1.2088|
                  |L1.1880|
;;;663        }
;;;664        else
;;;665        {
;;;666        /* Convert ascii string to integer. Do not validate sector numbers as it is
;;;667           done in IAP erase sector. Parameter type is deliberately 
;;;668           set to NO_PARAM_CHECK so that param_check function just converts ascii to integer 
;;;669        */
;;;670            result_table[IAP_STAT_CODE] = param_check(param_buf[ISP_PARAM_1], \
000758  4963              LDR      r1,|L1.2280|
00075a  2300              MOVS     r3,#0
00075c  2269              MOVS     r2,#0x69
00075e  6848              LDR      r0,[r1,#4]  ; param_buf
000760  4963              LDR      r1,|L1.2288|
000762  f7fffffe          BL       param_check
000766  4963              LDR      r1,|L1.2292|
000768  6008              STR      r0,[r1,#0]  ; result_table
;;;671            &param_table[IAP_PARAM_0],NO_PARAM_CHECK,NUL);
;;;672    
;;;673            if( result_table[IAP_STAT_CODE] == CMD_SUCCESS )
00076a  0008              MOVS     r0,r1
00076c  6800              LDR      r0,[r0,#0]  ; result_table
00076e  2800              CMP      r0,#0
000770  d109              BNE      |L1.1926|
;;;674            {
;;;675                result_table[IAP_STAT_CODE] = param_check(param_buf[ISP_PARAM_2], \
000772  495d              LDR      r1,|L1.2280|
000774  2300              MOVS     r3,#0
000776  2269              MOVS     r2,#0x69
000778  6888              LDR      r0,[r1,#8]  ; param_buf
00077a  495d              LDR      r1,|L1.2288|
00077c  1d09              ADDS     r1,r1,#4
00077e  f7fffffe          BL       param_check
000782  495c              LDR      r1,|L1.2292|
000784  6008              STR      r0,[r1,#0]  ; result_table
                  |L1.1926|
;;;676                &param_table[IAP_PARAM_1],NO_PARAM_CHECK,NUL);
;;;677            }
;;;678    
;;;679            /* If code read protection level 2 or 3 is enabled allow erase command only when
;;;680               all sectors are selected for erase */
;;;681            if( (crp_after_reset == CRP2) ||                     \
000786  485c              LDR      r0,|L1.2296|
000788  6800              LDR      r0,[r0,#0]  ; crp_after_reset
00078a  495e              LDR      r1,|L1.2308|
00078c  4288              CMP      r0,r1
00078e  d004              BEQ      |L1.1946|
;;;682                (crp_after_reset == CRP3) 
000790  4859              LDR      r0,|L1.2296|
000792  6800              LDR      r0,[r0,#0]  ; crp_after_reset
000794  495c              LDR      r1,|L1.2312|
000796  4288              CMP      r0,r1
000798  d10d              BNE      |L1.1974|
                  |L1.1946|
;;;683               )
;;;684            {
;;;685                if( (param_table[IAP_PARAM_0] != USER_START_SECTOR) ||                         \
00079a  4855              LDR      r0,|L1.2288|
00079c  1f00              SUBS     r0,r0,#4
00079e  6840              LDR      r0,[r0,#4]  ; param_table
0007a0  2802              CMP      r0,#2
0007a2  d104              BNE      |L1.1966|
;;;686                    (param_table[IAP_PARAM_1] != USER_END_SECTOR)
0007a4  4852              LDR      r0,|L1.2288|
0007a6  1f00              SUBS     r0,r0,#4
0007a8  6880              LDR      r0,[r0,#8]  ; param_table
0007aa  281b              CMP      r0,#0x1b
0007ac  d015              BEQ      |L1.2010|
                  |L1.1966|
;;;687                  )
;;;688                {
;;;689                    result_table[IAP_STAT_CODE] = CODE_READ_PROTECTION_ENABLED;
0007ae  2013              MOVS     r0,#0x13
0007b0  4950              LDR      r1,|L1.2292|
0007b2  6008              STR      r0,[r1,#0]  ; result_table
0007b4  e011              B        |L1.2010|
                  |L1.1974|
;;;690                }
;;;691            }
;;;692    
;;;693            /* If code read protection level 1 is enabled allow erase command only when
;;;694               user start sector is NOT selected for erase */
;;;695            else if( (crp_after_reset == CRP1) )
0007b6  4850              LDR      r0,|L1.2296|
0007b8  6800              LDR      r0,[r0,#0]  ; crp_after_reset
0007ba  4950              LDR      r1,|L1.2300|
0007bc  4288              CMP      r0,r1
0007be  d10c              BNE      |L1.2010|
;;;696            {
;;;697               if( (param_table[IAP_PARAM_0] == USER_START_SECTOR) &&                         \
0007c0  484b              LDR      r0,|L1.2288|
0007c2  1f00              SUBS     r0,r0,#4
0007c4  6840              LDR      r0,[r0,#4]  ; param_table
0007c6  2802              CMP      r0,#2
0007c8  d107              BNE      |L1.2010|
;;;698                   (param_table[IAP_PARAM_1] != USER_END_SECTOR)
0007ca  4849              LDR      r0,|L1.2288|
0007cc  1f00              SUBS     r0,r0,#4
0007ce  6880              LDR      r0,[r0,#8]  ; param_table
0007d0  281b              CMP      r0,#0x1b
0007d2  d002              BEQ      |L1.2010|
;;;699                 )
;;;700                {
;;;701                    result_table[IAP_STAT_CODE] = CODE_READ_PROTECTION_ENABLED;
0007d4  2013              MOVS     r0,#0x13
0007d6  4947              LDR      r1,|L1.2292|
0007d8  6008              STR      r0,[r1,#0]  ; result_table
                  |L1.2010|
;;;702                }
;;;703            }
;;;704    
;;;705            if( result_table[IAP_STAT_CODE] == CMD_SUCCESS )
0007da  4846              LDR      r0,|L1.2292|
0007dc  6800              LDR      r0,[r0,#0]  ; result_table
0007de  2800              CMP      r0,#0
0007e0  d10b              BNE      |L1.2042|
;;;706            {
;;;707                param_table[IAP_CMD_CODE] = ERASE_SECTOR;
0007e2  2034              MOVS     r0,#0x34
0007e4  4942              LDR      r1,|L1.2288|
0007e6  1f09              SUBS     r1,r1,#4
0007e8  6008              STR      r0,[r1,#0]  ; param_table
;;;708                param_table[IAP_PARAM_2] = fcclk_KHz;
0007ea  4845              LDR      r0,|L1.2304|
0007ec  6800              LDR      r0,[r0,#0]  ; fcclk_KHz
0007ee  60c8              STR      r0,[r1,#0xc]  ; param_table
;;;709                iap_entry(param_table,result_table);
0007f0  4940              LDR      r1,|L1.2292|
0007f2  483f              LDR      r0,|L1.2288|
0007f4  1f00              SUBS     r0,r0,#4
0007f6  f7fffffe          BL       iap_entry
                  |L1.2042|
;;;710            }
;;;711            /* Update code protection status if all sectors are erased */
;;;712            if( (param_table[IAP_PARAM_0] == USER_START_SECTOR) &&                         \
0007fa  483d              LDR      r0,|L1.2288|
0007fc  1f00              SUBS     r0,r0,#4
0007fe  6840              LDR      r0,[r0,#4]  ; param_table
000800  2802              CMP      r0,#2
000802  d107              BNE      |L1.2068|
;;;713                (param_table[IAP_PARAM_1] == USER_END_SECTOR)
000804  483a              LDR      r0,|L1.2288|
000806  1f00              SUBS     r0,r0,#4
000808  6880              LDR      r0,[r0,#8]  ; param_table
00080a  281b              CMP      r0,#0x1b
00080c  d102              BNE      |L1.2068|
;;;714              )
;;;715            {
;;;716                crp_after_reset = NOCRP;       
00080e  483f              LDR      r0,|L1.2316|
000810  4939              LDR      r1,|L1.2296|
000812  6008              STR      r0,[r1,#0]  ; crp_after_reset
                  |L1.2068|
;;;717            }
;;;718            sendline_crlf(i_to_a(result_table[IAP_STAT_CODE],param_buf[ISP_PARAM_1], \
000814  4a34              LDR      r2,|L1.2280|
000816  6851              LDR      r1,[r2,#4]  ; param_buf
000818  4a36              LDR      r2,|L1.2292|
00081a  6810              LDR      r0,[r2,#0]  ; result_table
00081c  220f              MOVS     r2,#0xf
00081e  f7fffffe          BL       i_to_a
000822  0004              MOVS     r4,r0
000824  f7fffffe          BL       sendline_crlf
                  |L1.2088|
;;;719            PARAM_SIZE));
;;;720        }
;;;721    } /* erase */
000828  bc10              POP      {r4}
00082a  bc08              POP      {r3}
00082c  4718              BX       r3
;;;722    
                          ENDP

                  blank_check PROC
;;;723    void blank_check(void)
00082e  b510              PUSH     {r4,lr}
;;;724    {
;;;725        /* Convert ascii string to integer. Do not validate sector numbers as it is
;;;726           done in IAP blank check sector. Parameter type is deliberately 
;;;727           set to NO_PARAM_CHECK so that param_check function just converts ascii 
;;;728           to integer
;;;729        */
;;;730        result_table[IAP_STAT_CODE] = param_check(param_buf[ISP_PARAM_1], \
000830  492d              LDR      r1,|L1.2280|
000832  2300              MOVS     r3,#0
000834  2269              MOVS     r2,#0x69
000836  6848              LDR      r0,[r1,#4]  ; param_buf
000838  492d              LDR      r1,|L1.2288|
00083a  f7fffffe          BL       param_check
00083e  492d              LDR      r1,|L1.2292|
000840  6008              STR      r0,[r1,#0]  ; result_table
;;;731        &param_table[IAP_PARAM_0],NO_PARAM_CHECK,NUL);
;;;732        
;;;733        if( result_table[IAP_STAT_CODE] == CMD_SUCCESS )
000842  0008              MOVS     r0,r1
000844  6800              LDR      r0,[r0,#0]  ; result_table
000846  2800              CMP      r0,#0
000848  d109              BNE      |L1.2142|
;;;734        {
;;;735            result_table[IAP_STAT_CODE] = param_check(param_buf[ISP_PARAM_2], \
00084a  4927              LDR      r1,|L1.2280|
00084c  2300              MOVS     r3,#0
00084e  2269              MOVS     r2,#0x69
000850  6888              LDR      r0,[r1,#8]  ; param_buf
000852  4927              LDR      r1,|L1.2288|
000854  1d09              ADDS     r1,r1,#4
000856  f7fffffe          BL       param_check
00085a  4926              LDR      r1,|L1.2292|
00085c  6008              STR      r0,[r1,#0]  ; result_table
                  |L1.2142|
;;;736            &param_table[IAP_PARAM_1],NO_PARAM_CHECK,NUL);
;;;737        }    
;;;738        
;;;739        if( result_table[IAP_STAT_CODE] == CMD_SUCCESS )
00085e  4825              LDR      r0,|L1.2292|
000860  6800              LDR      r0,[r0,#0]  ; result_table
000862  2800              CMP      r0,#0
000864  d108              BNE      |L1.2168|
;;;740        {
;;;741            param_table[IAP_CMD_CODE] = BLANK_CHECK_SECTOR;
000866  2035              MOVS     r0,#0x35
000868  4921              LDR      r1,|L1.2288|
00086a  1f09              SUBS     r1,r1,#4
00086c  6008              STR      r0,[r1,#0]  ; param_table
;;;742            iap_entry(param_table,result_table);
00086e  4921              LDR      r1,|L1.2292|
000870  481f              LDR      r0,|L1.2288|
000872  1f00              SUBS     r0,r0,#4
000874  f7fffffe          BL       iap_entry
                  |L1.2168|
;;;743        }
;;;744        sendline_crlf(i_to_a(result_table[IAP_STAT_CODE],param_buf[ISP_PARAM_1], \
000878  4a1b              LDR      r2,|L1.2280|
00087a  6851              LDR      r1,[r2,#4]  ; param_buf
00087c  4a1d              LDR      r2,|L1.2292|
00087e  6810              LDR      r0,[r2,#0]  ; result_table
000880  220f              MOVS     r2,#0xf
000882  f7fffffe          BL       i_to_a
000886  0004              MOVS     r4,r0
000888  f7fffffe          BL       sendline_crlf
;;;745        PARAM_SIZE));
;;;746        if(result_table[IAP_STAT_CODE] == SECTOR_NOT_BLANK)
00088c  4819              LDR      r0,|L1.2292|
00088e  6800              LDR      r0,[r0,#0]  ; result_table
000890  2808              CMP      r0,#8
000892  d142              BNE      |L1.2330|
;;;747        {
;;;748            if( ( (crp_after_reset == CRP1)       ||       \
000894  4818              LDR      r0,|L1.2296|
000896  6800              LDR      r0,[r0,#0]  ; crp_after_reset
000898  4918              LDR      r1,|L1.2300|
00089a  4288              CMP      r0,r1
00089c  d009              BEQ      |L1.2226|
;;;749                  (crp_after_reset == CRP2)       ||       \
00089e  4816              LDR      r0,|L1.2296|
0008a0  6800              LDR      r0,[r0,#0]  ; crp_after_reset
0008a2  4918              LDR      r1,|L1.2308|
0008a4  4288              CMP      r0,r1
0008a6  d004              BEQ      |L1.2226|
;;;750                  (crp_after_reset == CRP3) )              \
0008a8  4813              LDR      r0,|L1.2296|
0008aa  6800              LDR      r0,[r0,#0]  ; crp_after_reset
0008ac  4916              LDR      r1,|L1.2312|
0008ae  4288              CMP      r0,r1
0008b0  d103              BNE      |L1.2234|
                  |L1.2226|
;;;751              )
;;;752            {
;;;753                result_table[IAP_RESULT_0]=0;
0008b2  2000              MOVS     r0,#0
0008b4  490f              LDR      r1,|L1.2292|
0008b6  6048              STR      r0,[r1,#4]  ; result_table
;;;754                result_table[IAP_RESULT_1]=0;
0008b8  6088              STR      r0,[r1,#8]  ; result_table
                  |L1.2234|
;;;755            }
;;;756            sendline_crlf(i_to_a(result_table[IAP_RESULT_0],param_buf[ISP_PARAM_1], \
0008ba  4a0b              LDR      r2,|L1.2280|
0008bc  6851              LDR      r1,[r2,#4]  ; param_buf
0008be  4a0d              LDR      r2,|L1.2292|
0008c0  6850              LDR      r0,[r2,#4]  ; result_table
0008c2  220f              MOVS     r2,#0xf
0008c4  f7fffffe          BL       i_to_a
0008c8  0004              MOVS     r4,r0
0008ca  f7fffffe          BL       sendline_crlf
;;;757            PARAM_SIZE));
;;;758            sendline_crlf(i_to_a(result_table[IAP_RESULT_1],param_buf[ISP_PARAM_1], \
0008ce  4a06              LDR      r2,|L1.2280|
0008d0  6851              LDR      r1,[r2,#4]  ; param_buf
0008d2  4a08              LDR      r2,|L1.2292|
0008d4  6890              LDR      r0,[r2,#8]  ; result_table
0008d6  220f              MOVS     r2,#0xf
0008d8  e01a              B        |L1.2320|
0008da  0000              DCW      0x0000
                  |L1.2268|
                          DCD      cmd_buf
                  |L1.2272|
                          DCD      ||ok||
                  |L1.2276|
                          DCD      lock
                  |L1.2280|
                          DCD      param_buf
                  |L1.2284|
                          DCD      0x00005a5a
                  |L1.2288|
                          DCD      param_table+0x4
                  |L1.2292|
                          DCD      result_table
                  |L1.2296|
                          DCD      crp_after_reset
                  |L1.2300|
                          DCD      0x12345678
                  |L1.2304|
                          DCD      fcclk_KHz
                  |L1.2308|
                          DCD      0x87654321
                  |L1.2312|
                          DCD      0x43218765
                  |L1.2316|
                          DCD      0x11223344
                  |L1.2320|
000910  f7fffffe          BL       i_to_a
000914  0004              MOVS     r4,r0
000916  f7fffffe          BL       sendline_crlf
                  |L1.2330|
;;;759            PARAM_SIZE));
;;;760        }
;;;761    } /* blank_check */
00091a  bc10              POP      {r4}
00091c  bc08              POP      {r3}
00091e  4718              BX       r3
;;;762    
                          ENDP

                  compare_mem PROC
;;;763    void compare_mem(void)
000920  b510              PUSH     {r4,lr}
;;;764    {
;;;765        /* Convert ascii string to integer. Do not validate address & count as it is
;;;766        done in IAP COMPARE command.Parameter type is deliberately 
;;;767        set to NO_PARAM_CHECK so that param_check function just converts ascii to integer
;;;768        */
;;;769        result_table[IAP_STAT_CODE] = param_check(param_buf[ISP_PARAM_1], \
000922  49e1              LDR      r1,|L1.3240|
000924  2300              MOVS     r3,#0
000926  2269              MOVS     r2,#0x69
000928  6848              LDR      r0,[r1,#4]  ; param_buf
00092a  49e0              LDR      r1,|L1.3244|
00092c  f7fffffe          BL       param_check
000930  49df              LDR      r1,|L1.3248|
000932  6008              STR      r0,[r1,#0]  ; result_table
;;;770        &param_table[IAP_PARAM_0],NO_PARAM_CHECK,NUL);
;;;771    
;;;772        if( result_table[IAP_STAT_CODE] == CMD_SUCCESS )
000934  0008              MOVS     r0,r1
000936  6800              LDR      r0,[r0,#0]  ; result_table
000938  2800              CMP      r0,#0
00093a  d109              BNE      |L1.2384|
;;;773        {
;;;774            result_table[IAP_STAT_CODE] = param_check(param_buf[ISP_PARAM_2], \
00093c  49da              LDR      r1,|L1.3240|
00093e  2300              MOVS     r3,#0
000940  2269              MOVS     r2,#0x69
000942  6888              LDR      r0,[r1,#8]  ; param_buf
000944  49d9              LDR      r1,|L1.3244|
000946  1d09              ADDS     r1,r1,#4
000948  f7fffffe          BL       param_check
00094c  49d8              LDR      r1,|L1.3248|
00094e  6008              STR      r0,[r1,#0]  ; result_table
                  |L1.2384|
;;;775            &param_table[IAP_PARAM_1],NO_PARAM_CHECK,NUL);
;;;776        }
;;;777    
;;;778        if( result_table[IAP_STAT_CODE] == CMD_SUCCESS )
000950  48d7              LDR      r0,|L1.3248|
000952  6800              LDR      r0,[r0,#0]  ; result_table
000954  2800              CMP      r0,#0
000956  d109              BNE      |L1.2412|
;;;779        {
;;;780            result_table[IAP_STAT_CODE] = param_check(param_buf[ISP_PARAM_3], \
000958  49d3              LDR      r1,|L1.3240|
00095a  2300              MOVS     r3,#0
00095c  2269              MOVS     r2,#0x69
00095e  68c8              LDR      r0,[r1,#0xc]  ; param_buf
000960  49d2              LDR      r1,|L1.3244|
000962  3108              ADDS     r1,r1,#8
000964  f7fffffe          BL       param_check
000968  49d1              LDR      r1,|L1.3248|
00096a  6008              STR      r0,[r1,#0]  ; result_table
                  |L1.2412|
;;;781            &param_table[IAP_PARAM_2],NO_PARAM_CHECK,NUL);
;;;782        }
;;;783    
;;;784        if( result_table[IAP_STAT_CODE] == CMD_SUCCESS )
00096c  48d0              LDR      r0,|L1.3248|
00096e  6800              LDR      r0,[r0,#0]  ; result_table
000970  2800              CMP      r0,#0
000972  d108              BNE      |L1.2438|
;;;785        {
;;;786            param_table[IAP_CMD_CODE] = COMPARE;
000974  2038              MOVS     r0,#0x38
000976  49cd              LDR      r1,|L1.3244|
000978  1f09              SUBS     r1,r1,#4
00097a  6008              STR      r0,[r1,#0]  ; param_table
;;;787            iap_entry(param_table,result_table);
00097c  49cc              LDR      r1,|L1.3248|
00097e  48cb              LDR      r0,|L1.3244|
000980  1f00              SUBS     r0,r0,#4
000982  f7fffffe          BL       iap_entry
                  |L1.2438|
;;;788        }
;;;789        sendline_crlf(i_to_a(result_table[IAP_STAT_CODE],param_buf[ISP_PARAM_1], \
000986  4ac8              LDR      r2,|L1.3240|
000988  6851              LDR      r1,[r2,#4]  ; param_buf
00098a  4ac9              LDR      r2,|L1.3248|
00098c  6810              LDR      r0,[r2,#0]  ; result_table
00098e  220f              MOVS     r2,#0xf
000990  f7fffffe          BL       i_to_a
000994  0004              MOVS     r4,r0
000996  f7fffffe          BL       sendline_crlf
;;;790        PARAM_SIZE));
;;;791        if(result_table[IAP_STAT_CODE] == COMPARE_ERROR)
00099a  48c5              LDR      r0,|L1.3248|
00099c  6800              LDR      r0,[r0,#0]  ; result_table
00099e  280a              CMP      r0,#0xa
0009a0  d109              BNE      |L1.2486|
;;;792        {
;;;793            sendline_crlf(i_to_a(result_table[IAP_RESULT_0],param_buf[ISP_PARAM_1], \
0009a2  4ac1              LDR      r2,|L1.3240|
0009a4  6851              LDR      r1,[r2,#4]  ; param_buf
0009a6  4ac2              LDR      r2,|L1.3248|
0009a8  6850              LDR      r0,[r2,#4]  ; result_table
0009aa  220f              MOVS     r2,#0xf
0009ac  f7fffffe          BL       i_to_a
0009b0  0004              MOVS     r4,r0
0009b2  f7fffffe          BL       sendline_crlf
                  |L1.2486|
;;;794            PARAM_SIZE));
;;;795        }
;;;796    }
0009b6  bc10              POP      {r4}
0009b8  bc08              POP      {r3}
0009ba  4718              BX       r3
;;;797    
                          ENDP

                  tokenize PROC
;;;798    int tokenize(char * in_buf,int no_of_chars_in_inbuf,char * out_buf[],   \
0009bc  b4ff              PUSH     {r0-r7}
;;;799                 int max_tokens,int max_chars_per_token )
;;;800    {
0009be  0004              MOVS     r4,r0
0009c0  0015              MOVS     r5,r2
;;;801        int i,token_count=0,pos=0, chars_in_token=0;
0009c2  2200              MOVS     r2,#0
0009c4  2300              MOVS     r3,#0
0009c6  2600              MOVS     r6,#0
;;;802    
;;;803        if(in_buf[0] == NUL)
0009c8  7820              LDRB     r0,[r4,#0]
0009ca  2800              CMP      r0,#0
0009cc  d102              BNE      |L1.2516|
                  |L1.2510|
;;;804        {
;;;805            return(0);
;;;806        }
;;;807        for(i=0;i<=no_of_chars_in_inbuf;i++)
;;;808        {
;;;809            if( token_count+1 > max_tokens)
;;;810            {
;;;811                return(token_count+1);
;;;812            }
;;;813            
;;;814            if( (in_buf[i] != SP)  &&                                      \
;;;815                (chars_in_token < (max_chars_per_token -2)) )
;;;816            {
;;;817                *(out_buf[token_count]+pos) = in_buf[i];
;;;818                pos++;
;;;819                chars_in_token++;
;;;820            }
;;;821            else if( (in_buf[i+1] != SP) ||                                \
;;;822                     (chars_in_token == (max_chars_per_token -2)) )
;;;823            {
;;;824                *(out_buf[token_count]+pos) = NUL;
;;;825                token_count++;
;;;826                pos=0;
;;;827                chars_in_token=0;
;;;828            }            
;;;829        }
;;;830        return(token_count+1);
;;;831    } /* tokenize */
0009ce  b004              ADD      sp,sp,#0x10
0009d0  bcf0              POP      {r4-r7}
0009d2  4770              BX       lr
                  |L1.2516|
0009d4  2100              MOVS     r1,#0                 ;807
0009d6  e022              B        |L1.2590|
                  |L1.2520|
0009d8  1c50              ADDS     r0,r2,#1              ;809
0009da  9f03              LDR      r7,[sp,#0xc]          ;809
0009dc  42b8              CMP      r0,r7                 ;809
0009de  dd00              BLE      |L1.2530|
0009e0  e7f5              B        |L1.2510|
                  |L1.2530|
0009e2  5c60              LDRB     r0,[r4,r1]            ;814
0009e4  2820              CMP      r0,#0x20              ;814
0009e6  d00a              BEQ      |L1.2558|
0009e8  9808              LDR      r0,[sp,#0x20]         ;815
0009ea  1e80              SUBS     r0,r0,#2              ;815
0009ec  42b0              CMP      r0,r6                 ;815
0009ee  dd06              BLE      |L1.2558|
0009f0  5c60              LDRB     r0,[r4,r1]            ;817
0009f2  0097              LSLS     r7,r2,#2              ;817
0009f4  59ef              LDR      r7,[r5,r7]            ;817
0009f6  54f8              STRB     r0,[r7,r3]            ;817
0009f8  1c5b              ADDS     r3,r3,#1              ;818
0009fa  1c76              ADDS     r6,r6,#1              ;819
0009fc  e00e              B        |L1.2588|
                  |L1.2558|
0009fe  1c48              ADDS     r0,r1,#1              ;821
000a00  5c20              LDRB     r0,[r4,r0]            ;821
000a02  2820              CMP      r0,#0x20              ;821
000a04  d103              BNE      |L1.2574|
000a06  9808              LDR      r0,[sp,#0x20]         ;822
000a08  1e80              SUBS     r0,r0,#2              ;822
000a0a  42b0              CMP      r0,r6                 ;822
000a0c  d106              BNE      |L1.2588|
                  |L1.2574|
000a0e  2000              MOVS     r0,#0                 ;824
000a10  0097              LSLS     r7,r2,#2              ;824
000a12  59ef              LDR      r7,[r5,r7]            ;824
000a14  54f8              STRB     r0,[r7,r3]            ;824
000a16  1c52              ADDS     r2,r2,#1              ;825
000a18  2300              MOVS     r3,#0                 ;826
000a1a  2600              MOVS     r6,#0                 ;827
                  |L1.2588|
000a1c  1c49              ADDS     r1,r1,#1              ;807
                  |L1.2590|
000a1e  9801              LDR      r0,[sp,#4]            ;807
000a20  4281              CMP      r1,r0                 ;807
000a22  ddd9              BLE      |L1.2520|
000a24  1c50              ADDS     r0,r2,#1              ;830
000a26  e7d2              B        |L1.2510|
;;;832    
                          ENDP

                  enable_interrupts PROC
;;;833    void enable_interrupts(unsigned interrupts)
000a28  49a2              LDR      r1,|L1.3252|
;;;834    {
;;;835        VICIntEnable = interrupts;
000a2a  6108              STR      r0,[r1,#0x10]
;;;836    }
000a2c  4770              BX       lr
;;;837    
                          ENDP

                  disable_interrupts PROC
;;;838    void disable_interrupts(unsigned interrupts)
000a2e  49a1              LDR      r1,|L1.3252|
;;;839    {
;;;840        VICIntEnClr = interrupts;
000a30  6148              STR      r0,[r1,#0x14]
;;;841    }
000a32  4770              BX       lr
;;;842    
                          ENDP

                  execute_user_code PROC
;;;843    void execute_user_code(void)
000a34  b510              PUSH     {r4,lr}
;;;844    {
;;;845        void (*user_code_entry)(void);
;;;846        user_code_entry = (void (*)(void))USER_START_SECTOR_ADDRESS;
000a36  2401              MOVS     r4,#1
000a38  0364              LSLS     r4,r4,#13
;;;847        user_code_entry();
000a3a  f7fffffe          BL       __ARM_common_call_via_r4
;;;848    }
000a3e  bc10              POP      {r4}
000a40  bc08              POP      {r3}
000a42  4718              BX       r3
;;;849    
                          ENDP

                  user_code_present PROC
;;;850    unsigned user_code_present(void)
000a44  b510              PUSH     {r4,lr}
;;;851    {
;;;852        param_table[IAP_CMD_CODE] = BLANK_CHECK_SECTOR;
000a46  2035              MOVS     r0,#0x35
000a48  4998              LDR      r1,|L1.3244|
000a4a  1f09              SUBS     r1,r1,#4
000a4c  6008              STR      r0,[r1,#0]  ; param_table
;;;853        param_table[IAP_PARAM_0] = USER_START_SECTOR;
000a4e  2002              MOVS     r0,#2
000a50  6048              STR      r0,[r1,#4]  ; param_table
;;;854        param_table[IAP_PARAM_1] = USER_START_SECTOR;
000a52  6088              STR      r0,[r1,#8]  ; param_table
;;;855        iap_entry(param_table,result_table);
000a54  4996              LDR      r1,|L1.3248|
000a56  4895              LDR      r0,|L1.3244|
000a58  1f00              SUBS     r0,r0,#4
000a5a  f7fffffe          BL       iap_entry
;;;856    	if( result_table[IAP_STAT_CODE] == CMD_SUCCESS )
000a5e  4894              LDR      r0,|L1.3248|
000a60  6800              LDR      r0,[r0,#0]  ; result_table
000a62  2800              CMP      r0,#0
000a64  d102              BNE      |L1.2668|
                  |L1.2662|
;;;857    	{
;;;858    	    return (FALSE);
;;;859    	}
;;;860    	else
;;;861    	{
;;;862    	    return (TRUE);
;;;863    	}
;;;864    }
000a66  bc10              POP      {r4}
000a68  bc08              POP      {r3}
000a6a  4718              BX       r3
                  |L1.2668|
000a6c  2001              MOVS     r0,#1                 ;862
000a6e  e7fa              B        |L1.2662|
;;;865    
                          ENDP

                  check_isp_entry_pin PROC
;;;866    unsigned check_isp_entry_pin(void)
000a70  4891              LDR      r0,|L1.3256|
;;;867    {
;;;868        if( (*(volatile unsigned *)ISP_ENTRY_GPIO_REG) & (0x1<<ISP_ENTRY_PIN) )
000a72  6800              LDR      r0,[r0,#0]
000a74  2101              MOVS     r1,#1
000a76  03c9              LSLS     r1,r1,#15
000a78  4008              ANDS     r0,r0,r1
000a7a  2800              CMP      r0,#0
000a7c  d001              BEQ      |L1.2690|
;;;869    	{
;;;870    	    return(TRUE);
000a7e  2001              MOVS     r0,#1
                  |L1.2688|
;;;871    	}
;;;872    	else
;;;873    	{
;;;874    	    return(FALSE);
;;;875    	}
;;;876    }
000a80  4770              BX       lr
                  |L1.2690|
000a82  2000              MOVS     r0,#0                 ;874
000a84  e7fc              B        |L1.2688|
;;;877    
                          ENDP

                  exec_isp_cmd PROC
;;;878    void exec_isp_cmd(int no_of_param)
000a86  b570              PUSH     {r4-r6,lr}
;;;879    {
000a88  0005              MOVS     r5,r0
;;;880        int c;
;;;881    
;;;882        c = *(param_buf[ISP_CMD_CODE]);
000a8a  4887              LDR      r0,|L1.3240|
000a8c  6800              LDR      r0,[r0,#0]  ; param_buf
000a8e  7804              LDRB     r4,[r0,#0]
;;;883        if(c != NUL);
;;;884        {
;;;885            switch(c)
000a90  0020              MOVS     r0,r4
000a92  3843              SUBS     r0,r0,#0x43
000a94  0003              MOVS     r3,r0
000a96  f7fffffe          BL       __ARM_common_switch8
000a9a  1563              DCB      0x15,0x63
000a9c  6f666f12          DCB      0x6f,0x66,0x6f,0x12
000aa0  6f691836          DCB      0x6f,0x69,0x18,0x36
000aa4  6f6c6f6f          DCB      0x6f,0x6c,0x6f,0x6f
000aa8  606f0f6f          DCB      0x60,0x6f,0x0f,0x6f
000aac  6f156f0c          DCB      0x6f,0x15,0x6f,0x0c
000ab0  6f00              DCB      0x6f,0x00
;;;886            {
;;;887            /* Write to RAM command */
;;;888            case 'W':
;;;889                write_to_ram();
000ab2  f7fffffe          BL       write_to_ram
;;;890                break;
000ab6  e069              B        |L1.2956|
;;;891            /* Read command */
;;;892            case 'R':
;;;893                read();
000ab8  f7fffffe          BL       read
;;;894                break;
000abc  e066              B        |L1.2956|
;;;895            /* Go command */
;;;896            case 'G':
;;;897                go_cmd();
000abe  f7fffffe          BL       go_cmd
;;;898                break;
000ac2  e063              B        |L1.2956|
;;;899            /* Unlock command */
;;;900            case 'U':
;;;901                unlock();
000ac4  f7fffffe          BL       unlock
;;;902                break;
000ac8  e060              B        |L1.2956|
;;;903            /* Read Part Identification number command */
;;;904            case 'J':
;;;905                param_table[IAP_CMD_CODE] = READ_PART_ID;
000aca  2036              MOVS     r0,#0x36
000acc  4977              LDR      r1,|L1.3244|
000ace  1f09              SUBS     r1,r1,#4
000ad0  6008              STR      r0,[r1,#0]  ; param_table
;;;906                iap_entry(param_table,result_table);
000ad2  4977              LDR      r1,|L1.3248|
000ad4  4875              LDR      r0,|L1.3244|
000ad6  1f00              SUBS     r0,r0,#4
000ad8  f7fffffe          BL       iap_entry
;;;907                sendline_crlf(i_to_a(result_table[IAP_STAT_CODE],param_buf[ISP_PARAM_1], \
000adc  4a72              LDR      r2,|L1.3240|
000ade  6851              LDR      r1,[r2,#4]  ; param_buf
000ae0  4a73              LDR      r2,|L1.3248|
000ae2  6810              LDR      r0,[r2,#0]  ; result_table
000ae4  220f              MOVS     r2,#0xf
000ae6  f7fffffe          BL       i_to_a
000aea  0006              MOVS     r6,r0
000aec  f7fffffe          BL       sendline_crlf
;;;908                PARAM_SIZE));
;;;909                sendline_crlf(i_to_a(result_table[IAP_RESULT_0],param_buf[ISP_PARAM_1], \
000af0  4a6d              LDR      r2,|L1.3240|
000af2  6851              LDR      r1,[r2,#4]  ; param_buf
000af4  4a6e              LDR      r2,|L1.3248|
000af6  6850              LDR      r0,[r2,#4]  ; result_table
000af8  220f              MOVS     r2,#0xf
000afa  f7fffffe          BL       i_to_a
000afe  0006              MOVS     r6,r0
000b00  f7fffffe          BL       sendline_crlf
;;;910                PARAM_SIZE));
;;;911            break;
000b04  e042              B        |L1.2956|
;;;912            /* Read Boot Code Version number command */
;;;913            case 'K':
;;;914                param_table[IAP_CMD_CODE] = READ_BOOT_VER;
000b06  2037              MOVS     r0,#0x37
000b08  4968              LDR      r1,|L1.3244|
000b0a  1f09              SUBS     r1,r1,#4
000b0c  6008              STR      r0,[r1,#0]  ; param_table
;;;915                iap_entry(param_table,result_table);
000b0e  4968              LDR      r1,|L1.3248|
000b10  4866              LDR      r0,|L1.3244|
000b12  1f00              SUBS     r0,r0,#4
000b14  f7fffffe          BL       iap_entry
;;;916                sendline_crlf(i_to_a(result_table[IAP_STAT_CODE],param_buf[ISP_PARAM_1], \
000b18  4a63              LDR      r2,|L1.3240|
000b1a  6851              LDR      r1,[r2,#4]  ; param_buf
000b1c  4a64              LDR      r2,|L1.3248|
000b1e  6810              LDR      r0,[r2,#0]  ; result_table
000b20  220f              MOVS     r2,#0xf
000b22  f7fffffe          BL       i_to_a
000b26  0006              MOVS     r6,r0
000b28  f7fffffe          BL       sendline_crlf
;;;917                PARAM_SIZE));
;;;918                sendline_crlf(i_to_a((char)result_table[IAP_RESULT_0],param_buf[ISP_PARAM_1], \
000b2c  4a5e              LDR      r2,|L1.3240|
000b2e  6851              LDR      r1,[r2,#4]  ; param_buf
000b30  4a5f              LDR      r2,|L1.3248|
000b32  7910              LDRB     r0,[r2,#4]  ; result_table
000b34  220f              MOVS     r2,#0xf
000b36  f7fffffe          BL       i_to_a
000b3a  0006              MOVS     r6,r0
000b3c  f7fffffe          BL       sendline_crlf
;;;919                PARAM_SIZE));
;;;920                sendline_crlf(i_to_a((char)(result_table[IAP_RESULT_0]>>8),param_buf[ISP_PARAM_1], \
000b40  4a59              LDR      r2,|L1.3240|
000b42  6851              LDR      r1,[r2,#4]  ; param_buf
000b44  4a5a              LDR      r2,|L1.3248|
000b46  8892              LDRH     r2,[r2,#4]  ; result_table
000b48  0412              LSLS     r2,r2,#16
000b4a  0e10              LSRS     r0,r2,#24
000b4c  220f              MOVS     r2,#0xf
000b4e  f7fffffe          BL       i_to_a
000b52  0006              MOVS     r6,r0
000b54  f7fffffe          BL       sendline_crlf
;;;921                PARAM_SIZE));
;;;922                break;
000b58  e018              B        |L1.2956|
;;;923            /* Prepare sector for write operation command */
;;;924            case 'P':
;;;925                prepare_sector();
000b5a  f7fffffe          BL       prepare_sector
;;;926                break;
000b5e  e015              B        |L1.2956|
;;;927            /* Copy RAM to FLASH command */
;;;928            case 'C':
;;;929                copy();
000b60  f7fffffe          BL       copy
;;;930                break;
000b64  e012              B        |L1.2956|
;;;931            /* Erase sector command */
;;;932            case 'E':
;;;933                erase();
000b66  f7fffffe          BL       erase
;;;934                break;
000b6a  e00f              B        |L1.2956|
;;;935            /* Blank check sector command */
;;;936            case 'I':
;;;937                blank_check();
000b6c  f7fffffe          BL       blank_check
;;;938                break;
000b70  e00c              B        |L1.2956|
;;;939            /* Compare Memory */
;;;940            case 'M':
;;;941                compare_mem();
000b72  f7fffffe          BL       compare_mem
;;;942                break;
000b76  e009              B        |L1.2956|
;;;943            /* Invalid Command */
;;;944            default:
;;;945                sendline_crlf(i_to_a(INVALID_COMMAND,param_buf[ISP_PARAM_1], \
000b78  484b              LDR      r0,|L1.3240|
000b7a  220f              MOVS     r2,#0xf
000b7c  6841              LDR      r1,[r0,#4]  ; param_buf
000b7e  2001              MOVS     r0,#1
000b80  f7fffffe          BL       i_to_a
000b84  0006              MOVS     r6,r0
000b86  f7fffffe          BL       sendline_crlf
;;;946                PARAM_SIZE));
;;;947                break;
000b8a  46c0              MOV      r8,r8
                  |L1.2956|
000b8c  46c0              MOV      r8,r8                 ;890
;;;948            } /* switch(c) */
;;;949        } /* if c != NUL */
;;;950    } /* exec_isp_cmd */
000b8e  bc70              POP      {r4-r6}
000b90  bc08              POP      {r3}
000b92  4718              BX       r3
;;;951    
                          ENDP

                  isp_cmd_loop PROC
;;;952    /* only returns if timeout occurred */
;;;953    void isp_cmd_loop(void)
000b94  b5fe              PUSH     {r1-r7,lr}
;;;954    {
;;;955        int cmd_len,no_of_param,crp_block_common_cmd,crp_block_crp2_crp3_cmd;
;;;956    	int result;
;;;957        
;;;958    	/* initialize to avoid compiler warning  */
;;;959        /* Lock Flash Write/Erase/Go Commands */
;;;960        lock = TRUE;
000b96  2001              MOVS     r0,#1
000b98  4948              LDR      r1,|L1.3260|
000b9a  6008              STR      r0,[r1,#0]  ; lock
;;;961        
;;;962        /* intialize parameter buffer */
;;;963        param_buf[ISP_PARAM_0] = param0;
000b9c  4848              LDR      r0,|L1.3264|
000b9e  4942              LDR      r1,|L1.3240|
000ba0  6008              STR      r0,[r1,#0]  ; param_buf
;;;964        param_buf[ISP_PARAM_1] = param1;
000ba2  4848              LDR      r0,|L1.3268|
000ba4  6048              STR      r0,[r1,#4]  ; param_buf
;;;965        param_buf[ISP_PARAM_2] = param2;
000ba6  4848              LDR      r0,|L1.3272|
000ba8  6088              STR      r0,[r1,#8]  ; param_buf
;;;966        param_buf[ISP_PARAM_3] = param3;
000baa  4848              LDR      r0,|L1.3276|
000bac  60c8              STR      r0,[r1,#0xc]  ; param_buf
;;;967        param_buf[ISP_PARAM_4] = param4;
000bae  4848              LDR      r0,|L1.3280|
000bb0  6108              STR      r0,[r1,#0x10]  ; param_buf
;;;968    
;;;969        /* Initialize cp_after_reset variable to allow ISP session to program 
;;;970           code protection enabled user application */
;;;971    	crp_after_reset = crp;
000bb2  4848              LDR      r0,|L1.3284|
000bb4  6800              LDR      r0,[r0,#0]  ; crp
000bb6  4948              LDR      r1,|L1.3288|
000bb8  6008              STR      r0,[r1,#0]  ; crp_after_reset
;;;972    
;;;973    	crp_block_crp2_crp3_cmd = TRUE;
000bba  2701              MOVS     r7,#1
;;;974    
;;;975    	while(1)
000bbc  e073              B        |L1.3238|
                  |L1.3006|
;;;976        {
;;;977    	    result = getline(cmd_buf,CMD_SIZE,&cmd_len);
000bbe  aa01              ADD      r2,sp,#4
000bc0  2146              MOVS     r1,#0x46
000bc2  4846              LDR      r0,|L1.3292|
000bc4  f7fffffe          BL       getline
000bc8  0005              MOVS     r5,r0
;;;978            if(result == 0)
000bca  2d00              CMP      r5,#0
000bcc  d168              BNE      |L1.3232|
;;;979            {
;;;980                /* To safegaurd against insufficient parameters fill parameter buffers with
;;;981                   Non numeric ascii charcaters */
;;;982                for(no_of_param=0;no_of_param<NO_OF_ISP_PARAMS;no_of_param++)
000bce  2400              MOVS     r4,#0
000bd0  e005              B        |L1.3038|
                  |L1.3026|
;;;983                {
;;;984                    *(param_buf[no_of_param]) = 'z';
000bd2  207a              MOVS     r0,#0x7a
000bd4  00a1              LSLS     r1,r4,#2
000bd6  4a34              LDR      r2,|L1.3240|
000bd8  5851              LDR      r1,[r2,r1]
000bda  7008              STRB     r0,[r1,#0]
000bdc  1c64              ADDS     r4,r4,#1              ;982
                  |L1.3038|
000bde  2c05              CMP      r4,#5                 ;982
000be0  dbf7              BLT      |L1.3026|
;;;985                }
;;;986                no_of_param = tokenize(&cmd_buf[0],cmd_len,&param_buf[0],NO_OF_ISP_PARAMS,PARAM_SIZE);  
000be2  200f              MOVS     r0,#0xf
000be4  2305              MOVS     r3,#5
000be6  4a30              LDR      r2,|L1.3240|
000be8  9000              STR      r0,[sp,#0]
000bea  483c              LDR      r0,|L1.3292|
000bec  9901              LDR      r1,[sp,#4]
000bee  f7fffffe          BL       tokenize
000bf2  0004              MOVS     r4,r0
;;;987                if(no_of_param != 0)
000bf4  2c00              CMP      r4,#0
000bf6  d056              BEQ      |L1.3238|
;;;988                {
;;;989                   /* Common ISP commands to be blocked for code read protection Level 1, 2 or 3 */
;;;990                   if( ( (*(param_buf[ISP_CMD_CODE]) == 'R') ||              \
000bf8  482b              LDR      r0,|L1.3240|
000bfa  6800              LDR      r0,[r0,#0]  ; param_buf
000bfc  7800              LDRB     r0,[r0,#0]
000bfe  2852              CMP      r0,#0x52
000c00  d009              BEQ      |L1.3094|
;;;991                         (*(param_buf[ISP_CMD_CODE]) == 'G') ||              \
000c02  4829              LDR      r0,|L1.3240|
000c04  6800              LDR      r0,[r0,#0]  ; param_buf
000c06  7800              LDRB     r0,[r0,#0]
000c08  2847              CMP      r0,#0x47
000c0a  d004              BEQ      |L1.3094|
;;;992                         (*(param_buf[ISP_CMD_CODE]) == 'M') ) )
000c0c  4826              LDR      r0,|L1.3240|
000c0e  6800              LDR      r0,[r0,#0]  ; param_buf
000c10  7800              LDRB     r0,[r0,#0]
000c12  284d              CMP      r0,#0x4d
000c14  d101              BNE      |L1.3098|
                  |L1.3094|
;;;993                   {
;;;994                      crp_block_common_cmd = TRUE;
000c16  2601              MOVS     r6,#1
000c18  e00d              B        |L1.3126|
                  |L1.3098|
;;;995                   }
;;;996                   else
;;;997                   {
;;;998                      crp_block_common_cmd = FALSE;
000c1a  2600              MOVS     r6,#0
;;;999                      /* ISP commands to be blocked for code read protection Level 2 and 3 */
;;;1000                     if( ( (*(param_buf[ISP_CMD_CODE]) == 'W') ||              \
000c1c  4822              LDR      r0,|L1.3240|
000c1e  6800              LDR      r0,[r0,#0]  ; param_buf
000c20  7800              LDRB     r0,[r0,#0]
000c22  2857              CMP      r0,#0x57
000c24  d004              BEQ      |L1.3120|
;;;1001                           (*(param_buf[ISP_CMD_CODE]) == 'C') ) )
000c26  4820              LDR      r0,|L1.3240|
000c28  6800              LDR      r0,[r0,#0]  ; param_buf
000c2a  7800              LDRB     r0,[r0,#0]
000c2c  2843              CMP      r0,#0x43
000c2e  d101              BNE      |L1.3124|
                  |L1.3120|
;;;1002                     {
;;;1003                        crp_block_crp2_crp3_cmd = TRUE;
000c30  2701              MOVS     r7,#1
000c32  e000              B        |L1.3126|
                  |L1.3124|
;;;1004                     }
;;;1005                     else
;;;1006                     {
;;;1007                        crp_block_crp2_crp3_cmd = FALSE;
000c34  2700              MOVS     r7,#0
                  |L1.3126|
;;;1008                     }
;;;1009                  }
;;;1010   
;;;1011                  if( ( (crp_after_reset == CRP1) ||            \
000c36  4828              LDR      r0,|L1.3288|
000c38  6800              LDR      r0,[r0,#0]  ; crp_after_reset
000c3a  4929              LDR      r1,|L1.3296|
000c3c  4288              CMP      r0,r1
000c3e  d009              BEQ      |L1.3156|
;;;1012                        (crp_after_reset == CRP2) ||     \
000c40  4825              LDR      r0,|L1.3288|
000c42  6800              LDR      r0,[r0,#0]  ; crp_after_reset
000c44  4927              LDR      r1,|L1.3300|
000c46  4288              CMP      r0,r1
000c48  d004              BEQ      |L1.3156|
;;;1013                        (crp_after_reset == CRP3) )      \
000c4a  4823              LDR      r0,|L1.3288|
000c4c  6800              LDR      r0,[r0,#0]  ; crp_after_reset
000c4e  4926              LDR      r1,|L1.3304|
000c50  4288              CMP      r0,r1
000c52  d10b              BNE      |L1.3180|
                  |L1.3156|
;;;1014                                           &&                                 \
;;;1015                       ( crp_block_common_cmd == TRUE )
000c54  2e01              CMP      r6,#1
000c56  d109              BNE      |L1.3180|
;;;1016                     )
;;;1017                   {
;;;1018                       /* Code read protection Level 1, 2 or 3 enabled. Block Read,
;;;1019                          Go and Compare ISP commands */
;;;1020                       sendline_crlf(i_to_a(CODE_READ_PROTECTION_ENABLED, \
000c58  4813              LDR      r0,|L1.3240|
000c5a  220f              MOVS     r2,#0xf
000c5c  6841              LDR      r1,[r0,#4]  ; param_buf
000c5e  2013              MOVS     r0,#0x13
000c60  f7fffffe          BL       i_to_a
000c64  9000              STR      r0,[sp,#0]
000c66  f7fffffe          BL       sendline_crlf
000c6a  e01c              B        |L1.3238|
                  |L1.3180|
;;;1021                       param_buf[ISP_PARAM_1],PARAM_SIZE));
;;;1022                   }  
;;;1023                   else
;;;1024                   {
;;;1025                      if( ( (crp_after_reset == CRP2) ||            \
000c6c  481a              LDR      r0,|L1.3288|
000c6e  6800              LDR      r0,[r0,#0]  ; crp_after_reset
000c70  491c              LDR      r1,|L1.3300|
000c72  4288              CMP      r0,r1
000c74  d004              BEQ      |L1.3200|
;;;1026                            (crp_after_reset == CRP3) )  
000c76  4818              LDR      r0,|L1.3288|
000c78  6800              LDR      r0,[r0,#0]  ; crp_after_reset
000c7a  491b              LDR      r1,|L1.3304|
000c7c  4288              CMP      r0,r1
000c7e  d10b              BNE      |L1.3224|
                  |L1.3200|
;;;1027                                            &&                                   \
;;;1028                           ( crp_block_crp2_crp3_cmd == TRUE ) )
000c80  2f01              CMP      r7,#1
000c82  d109              BNE      |L1.3224|
;;;1029                      {
;;;1030                       /* Code read protection Level 2 or 3 is enabled. Block Write
;;;1031                          and Copy ISP commands */
;;;1032                          sendline_crlf(i_to_a(CODE_READ_PROTECTION_ENABLED, \
000c84  4808              LDR      r0,|L1.3240|
000c86  220f              MOVS     r2,#0xf
000c88  6841              LDR      r1,[r0,#4]  ; param_buf
000c8a  2013              MOVS     r0,#0x13
000c8c  f7fffffe          BL       i_to_a
000c90  9000              STR      r0,[sp,#0]
000c92  f7fffffe          BL       sendline_crlf
000c96  e006              B        |L1.3238|
                  |L1.3224|
;;;1033                          param_buf[ISP_PARAM_1],PARAM_SIZE));
;;;1034                      }
;;;1035                      else
;;;1036                      {
;;;1037                          exec_isp_cmd(no_of_param);
000c98  0020              MOVS     r0,r4
000c9a  f7fffffe          BL       exec_isp_cmd
000c9e  e002              B        |L1.3238|
                  |L1.3232|
;;;1038                      }
;;;1039                   }
;;;1040               } /* if(no_of_param != 0) */
;;;1041           } /* if(serial_getline(cmd_buf,CMD_SIZE,&cmd_len) == 0) */
;;;1042   		else
;;;1043   		{
;;;1044   		  /* timeout */
;;;1045   		  return;
;;;1046   		}
;;;1047   	} /* While(1) loop */
;;;1048   } /* isp_cmd_loop */
000ca0  bcfe              POP      {r1-r7}
000ca2  bc08              POP      {r3}
000ca4  4718              BX       r3
                  |L1.3238|
000ca6  e78a              B        |L1.3006|
                          ENDP

                  |L1.3240|
                          DCD      param_buf
                  |L1.3244|
                          DCD      param_table+0x4
                  |L1.3248|
                          DCD      result_table
                  |L1.3252|
                          DCD      0xfffff000
                  |L1.3256|
                          DCD      0xe0028000
                  |L1.3260|
                          DCD      lock
                  |L1.3264|
                          DCD      param0
                  |L1.3268|
                          DCD      param1
                  |L1.3272|
                          DCD      param2
                  |L1.3276|
                          DCD      param3
                  |L1.3280|
                          DCD      param4
                  |L1.3284|
                          DCD      ||crp||
                  |L1.3288|
                          DCD      crp_after_reset
                  |L1.3292|
                          DCD      cmd_buf
                  |L1.3296|
                          DCD      0x12345678
                  |L1.3300|
                          DCD      0x87654321
                  |L1.3304|
                          DCD      0x43218765

                          AREA ||.bss||, DATA, NOINIT, ALIGN=2

                  cmd_buf
                          %        70
                  param0
                          %        15
                  param1
                          %        15
                  param2
                          %        15
                  param3
                          %        15
                  param4
                          %        18
                  param_buf
                          %        20
                  param_table
                          %        20
                  result_table
                          %        20

                          AREA ||.constdata||, DATA, READONLY, ALIGN=2

                  unlock_code
                          DCD      0x00005a5a
                  sync_str
000004  53796e63          DCB      0x53,0x79,0x6e,0x63
000008  68726f6e          DCB      0x68,0x72,0x6f,0x6e
00000c  697a6564          DCB      0x69,0x7a,0x65,0x64
000010  00                DCB      0x00
                  ||ok||
000011  4f4b00            DCB      0x4f,0x4b,0x00
                  resend
000014  52455345          DCB      0x52,0x45,0x53,0x45
000018  4e4400            DCB      0x4e,0x44,0x00

                          AREA ||.data||, DATA, ALIGN=2

                  lock
                          DCD      0x00000000
                  crp_after_reset
                          DCD      0x00000000

                          AREA ||i.__ARM_common_switch8||, COMGROUP=__ARM_common_switch8, CODE, READONLY, ALIGN=2

                          ARM
                  __ARM_common_switch8 PROC
000000  e55ec001          LDRB     r12,[lr,#-1]
000004  e153000c          CMP      r3,r12
000008  3a000001          BCC      |L18.20|
00000c  e7de300c          LDRB     r3,[lr,r12]
000010  ea000000          B        |L18.24|
                  |L18.20|
000014  e7de3003          LDRB     r3,[lr,r3]
                  |L18.24|
000018  e08ec083          ADD      r12,lr,r3,LSL #1
00001c  e12fff1c          BX       r12
                          ENDP


                          AREA ||i.__ARM_common_call_via_r4||, COMGROUP=__ARM_common_call_via_r4, CODE, READONLY, ALIGN=1

                          THUMB
                  __ARM_common_call_via_r4 PROC
000000  4720              BX       r4
                          ENDP


                          AREA ||i.__ARM_common_call_via_r0||, COMGROUP=__ARM_common_call_via_r0, CODE, READONLY, ALIGN=1

                  __ARM_common_call_via_r0 PROC
000000  4700              BX       r0
                          ENDP


                          AREA ||i.__ARM_common_call_via_r6||, COMGROUP=__ARM_common_call_via_r6, CODE, READONLY, ALIGN=1

                  __ARM_common_call_via_r6 PROC
000000  4730              BX       r6
                          ENDP

